npm - opencode-skills-collection - Versions diffs - 4.0.53 → 4.0.54 - Mend

opencode-skills-collection 4.0.53 → 4.0.54

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1168) hide show

package/bundled-skills/agentphone/SKILL.md CHANGED Viewed

@@ -4,6 +4,7 @@ version: 0.3.0
 description: Build AI phone agents with AgentPhone API. Use when the user wants to make phone calls, send/receive SMS, manage phone numbers, create voice agents, set up webhooks, or check usage — anything related to telephony, phone numbers, or voice AI.
 risk: critical
 source: community
+date_added: "2026-09-04"
 homepage: https://agentphone.to
 docs: https://docs.agentphone.to
 metadata: {"api_base": "https://api.agentphone.to/v1"}
@@ -13,6 +14,10 @@ metadata: {"api_base": "https://api.agentphone.to/v1"}
 AgentPhone is an API-first telephony platform for AI agents. Give your agents phone numbers, voice calls, and SMS — all managed through a simple API.
+## Detailed Guide
+Read [the detailed guide](references/detailed-guide.md) before executing this skill. It retains the complete procedure and reference material. Treat its safety, prerequisites, and validation requirements as mandatory. For focused work, load the relevant sections; for end-to-end work, read the guide completely.
 ## When to Use
 - Use when the user wants to create or manage AI phone agents, voice agents, or telephony automations
 - Use when the user needs to buy, assign, release, or inspect phone numbers tied to an agent workflow
@@ -28,164 +33,6 @@ AgentPhone is an API-first telephony platform for AI agents. Give your agents ph
 ---
-## How It Works
-AgentPhone lets you create AI agents that can make and receive phone calls and SMS messages. Here's the full lifecycle:
-1. You sign up at [agentphone.to](https://agentphone.to) and get an API key
-2. You create an **Agent** — this is the AI persona that handles calls and messages
-3. You buy a **Phone Number** and attach it to the agent
-4. You configure a **Webhook** (for custom logic) or use **Hosted Mode** (built-in LLM handles the conversation)
-5. Your agent can now make outbound calls, receive inbound calls, and send/receive SMS
-```
-Account
-└── Agent (AI persona — owns numbers, handles calls/SMS)
-    ├── Phone Number (attached to agent)
-    │   ├── Call (inbound/outbound voice)
-    │   │   └── Transcript (call recording text)
-    │   └── Message (SMS)
-    │       └── Conversation (threaded SMS exchange)
-    └── Webhook (per-agent event delivery)
-Webhook (project-level event delivery)
-```
-### Voice Modes
-Agents operate in one of two modes:
-- **`hosted`** — The built-in LLM handles the conversation autonomously using the agent's `system_prompt`. No server required. This is the easiest way to get started — just set a prompt and make a call.
-- **`webhook`** (default) — Inbound call/SMS events are forwarded to your webhook URL for custom handling. Use this when you need full control over the conversation logic.
----
-## Quick Start
-### Step 1: Get Your API Key
-Sign up at [agentphone.to](https://agentphone.to). Your API key will look like `sk_live_abc123...`.
-### Step 2: Create an Agent
-```bash
-curl -X POST https://api.agentphone.to/v1/agents \
-  -H "Authorization: Bearer YOUR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "name": "Support Bot",
-    "description": "Handles customer support calls",
-    "voiceMode": "hosted",
-    "systemPrompt": "You are a friendly customer support agent. Help the caller with their questions.",
-    "beginMessage": "Hi there! How can I help you today?"
-  }'
-```
-**Response:**
-```json
-{
-  "id": "agent_abc123",
-  "name": "Support Bot",
-  "description": "Handles customer support calls",
-  "voiceMode": "hosted",
-  "systemPrompt": "You are a friendly customer support agent...",
-  "beginMessage": "Hi there! How can I help you today?",
-  "voice": "11labs-Brian",
-  "phoneNumbers": [],
-  "createdAt": "2025-01-15T10:30:00.000Z"
-}
-```
-### Step 3: Buy a Phone Number
-```bash
-curl -X POST https://api.agentphone.to/v1/numbers \
-  -H "Authorization: Bearer YOUR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "country": "US",
-    "areaCode": "415",
-    "agentId": "agent_abc123"
-  }'
-```
-**Response:**
-```json
-{
-  "id": "pn_xyz789",
-  "phoneNumber": "+14155551234",
-  "country": "US",
-  "status": "active",
-  "agentId": "agent_abc123",
-  "createdAt": "2025-01-15T10:31:00.000Z"
-}
-```
-Your agent now has a phone number. It can receive inbound calls immediately.
-### Step 4: Make an Outbound Call
-```bash
-curl -X POST https://api.agentphone.to/v1/calls \
-  -H "Authorization: Bearer YOUR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "agentId": "agent_abc123",
-    "toNumber": "+14155559999",
-    "systemPrompt": "Schedule a dentist appointment for next Tuesday at 2pm.",
-    "initialGreeting": "Hi, I am calling to schedule an appointment."
-  }'
-```
-**Response:**
-```json
-{
-  "id": "call_def456",
-  "agentId": "agent_abc123",
-  "fromNumber": "+14155551234",
-  "toNumber": "+14155559999",
-  "direction": "outbound",
-  "status": "in-progress",
-  "startedAt": "2025-01-15T10:32:00.000Z"
-}
-```
-The AI will hold the entire conversation autonomously based on your prompt. Check the transcript after the call ends.
-### Step 5: Check the Transcript
-```bash
-curl https://api.agentphone.to/v1/calls/call_def456/transcript \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-**Response:**
-```json
-{
-  "data": [
-    {
-      "id": "tx_001",
-      "transcript": "Hi, I am calling to schedule an appointment.",
-      "response": null,
-      "confidence": 0.95,
-      "createdAt": "2025-01-15T10:32:01.000Z"
-    },
-    {
-      "id": "tx_002",
-      "transcript": "Sure, what day works for you?",
-      "response": "Next Tuesday at 2pm would be great.",
-      "confidence": 0.92,
-      "createdAt": "2025-01-15T10:32:05.000Z"
-    }
-  ]
-}
-```
----
 ## Rules
 These rules are important. Read them carefully.
@@ -217,1171 +64,6 @@ Always use **E.164 format** for phone numbers: `+` followed by country code and
 ---
-## Authentication
-All API requests require your API key in the `Authorization` header:
-```
-Authorization: Bearer YOUR_API_KEY
-```
-Get your API key at [agentphone.to](https://agentphone.to).
----
-## API Reference
-### Account
-#### Get Account Overview
-Get a complete snapshot of your account: agents, phone numbers, webhook status, and usage limits. **Call this first to orient yourself.**
-```bash
-curl https://api.agentphone.to/v1/usage \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-**Response:**
-```json
-{
-  "plan": { "name": "free", "numberLimit": 1 },
-  "numbers": { "used": 1, "limit": 1 },
-  "stats": {
-    "messagesLast30d": 42,
-    "callsLast30d": 15,
-    "minutesLast30d": 67
-  }
-}
-```
----
-### Agents
-#### Create an Agent
-```bash
-curl -X POST https://api.agentphone.to/v1/agents \
-  -H "Authorization: Bearer YOUR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "name": "Sales Agent",
-    "description": "Handles outbound sales calls",
-    "voiceMode": "hosted",
-    "systemPrompt": "You are a professional sales agent. Be persuasive but not pushy.",
-    "beginMessage": "Hi! Thanks for taking my call.",
-    "voice": "alloy"
-  }'
-```
-| Field | Type | Required | Description |
-|-------|------|----------|-------------|
-| `name` | `string` | Yes | Agent name |
-| `description` | `string` | No | What this agent does |
-| `voiceMode` | `"webhook"` \| `"hosted"` | No | Call handling mode (default: `webhook`) |
-| `systemPrompt` | `string` | No | LLM system prompt (required for `hosted` mode) |
-| `beginMessage` | `string` | No | Auto-greeting spoken when a call connects |
-| `voice` | `string` | No | Voice ID (use `list_voices` to see options) |
-**Response:**
-```json
-{
-  "id": "agent_abc123",
-  "name": "Sales Agent",
-  "description": "Handles outbound sales calls",
-  "voiceMode": "hosted",
-  "systemPrompt": "You are a professional sales agent...",
-  "beginMessage": "Hi! Thanks for taking my call.",
-  "voice": "alloy",
-  "phoneNumbers": [],
-  "createdAt": "2025-01-15T10:30:00.000Z"
-}
-```
-#### List Agents
-```bash
-curl "https://api.agentphone.to/v1/agents?limit=20" \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-| Parameter | Type | Required | Default | Description |
-|-----------|------|----------|---------|-------------|
-| `limit` | `number` | No | 20 | Max results (1-100) |
-#### Get an Agent
-```bash
-curl https://api.agentphone.to/v1/agents/AGENT_ID \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-Returns the agent with its phone numbers and voice configuration.
-#### Update an Agent
-Only provided fields are updated — everything else stays the same.
-```bash
-curl -X PATCH https://api.agentphone.to/v1/agents/AGENT_ID \
-  -H "Authorization: Bearer YOUR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "name": "Updated Bot",
-    "systemPrompt": "You are a customer support specialist. Be empathetic and helpful.",
-    "voice": "nova"
-  }'
-```
-| Field | Type | Required | Description |
-|-------|------|----------|-------------|
-| `name` | `string` | No | New name |
-| `description` | `string` | No | New description |
-| `voiceMode` | `"webhook"` \| `"hosted"` | No | Call handling mode |
-| `systemPrompt` | `string` | No | New system prompt |
-| `beginMessage` | `string` | No | New auto-greeting |
-| `voice` | `string` | No | New voice ID |
-#### Delete an Agent
-**Cannot be undone.** Phone numbers attached to the agent are kept but unassigned.
-```bash
-curl -X DELETE https://api.agentphone.to/v1/agents/AGENT_ID \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-**Response:**
-```json
-{
-  "success": true,
-  "message": "Agent deleted",
-  "unassignedNumbers": ["pn_xyz789"]
-}
-```
-#### Attach a Number to an Agent
-```bash
-curl -X POST https://api.agentphone.to/v1/agents/AGENT_ID/numbers \
-  -H "Authorization: Bearer YOUR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"numberId": "pn_xyz789"}'
-```
-| Field | Type | Required | Description |
-|-------|------|----------|-------------|
-| `numberId` | `string` | Yes | Phone number ID from `list_numbers` |
-#### Detach a Number from an Agent
-```bash
-curl -X DELETE https://api.agentphone.to/v1/agents/AGENT_ID/numbers/NUMBER_ID \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-#### List Agent Conversations
-Get SMS conversations for a specific agent.
-```bash
-curl "https://api.agentphone.to/v1/agents/AGENT_ID/conversations?limit=20" \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-#### List Agent Calls
-Get calls for a specific agent.
-```bash
-curl "https://api.agentphone.to/v1/agents/AGENT_ID/calls?limit=20" \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-#### List Available Voices
-See all available voice options for agents. Use the `voice_id` when creating or updating an agent.
-```bash
-curl https://api.agentphone.to/v1/agents/voices \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-**Response:**
-```json
-{
-  "data": [
-    { "voiceId": "11labs-Brian", "name": "Brian", "provider": "elevenlabs", "gender": "male" },
-    { "voiceId": "alloy", "name": "Alloy", "provider": "openai", "gender": "neutral" },
-    { "voiceId": "nova", "name": "Nova", "provider": "openai", "gender": "female" }
-  ]
-}
-```
----
-### Phone Numbers
-#### Buy a Phone Number
-```bash
-curl -X POST https://api.agentphone.to/v1/numbers \
-  -H "Authorization: Bearer YOUR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "country": "US",
-    "areaCode": "415",
-    "agentId": "agent_abc123"
-  }'
-```
-| Field | Type | Required | Default | Description |
-|-------|------|----------|---------|-------------|
-| `country` | `string` | No | `"US"` | 2-letter ISO country code (`US` or `CA`) |
-| `areaCode` | `string` | No | — | 3-digit area code (US/CA only) |
-| `agentId` | `string` | No | — | Attach to an agent immediately |
-**Response:**
-```json
-{
-  "id": "pn_xyz789",
-  "phoneNumber": "+14155551234",
-  "country": "US",
-  "status": "active",
-  "agentId": "agent_abc123",
-  "createdAt": "2025-01-15T10:31:00.000Z"
-}
-```
-#### List Phone Numbers
-```bash
-curl "https://api.agentphone.to/v1/numbers?limit=20" \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-| Parameter | Type | Required | Default | Description |
-|-----------|------|----------|---------|-------------|
-| `limit` | `number` | No | 20 | Max results (1-100) |
-**Response:**
-```json
-{
-  "data": [
-    {
-      "id": "pn_xyz789",
-      "phoneNumber": "+14155551234",
-      "country": "US",
-      "status": "active",
-      "agentId": "agent_abc123"
-    }
-  ],
-  "total": 1
-}
-```
-#### Release a Phone Number
-**Irreversible** — the number returns to the carrier pool and you cannot get it back. Always confirm with the user before releasing.
-```bash
-curl -X DELETE https://api.agentphone.to/v1/numbers/NUMBER_ID \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
----
-### Voice Calls
-Voice calls are real-time conversations through your agent's phone numbers. Calls can be inbound (received) or outbound (initiated via API). Each call includes metadata like duration, status, and transcript.
-How calls are handled depends on your agent's **voice mode**:
-- **`voiceMode: "webhook"`** (default) — Caller speech is transcribed and sent to your webhook as `agent.message` events. Your server controls every response using any LLM, RAG, or custom logic.
-- **`voiceMode: "hosted"`** — Calls are handled end-to-end by a built-in LLM using your `systemPrompt`. No webhook or server needed.
-Switch modes at any time via `PATCH /v1/agents/:id`. The backend automatically re-provisions voice infrastructure and rebinds phone numbers with no downtime.
-> **Note:** SMS is always webhook-based regardless of voice mode.
-#### Call flow (webhook mode)
-When `voiceMode` is `"webhook"`:
-1. **Caller dials your number** — The voice engine answers and begins streaming audio.
-2. **Caller speaks** — Streaming STT transcribes in real-time and detects end of speech.
-3. **Transcript is sent to your webhook** — We POST the transcript to your webhook with `event: "agent.message"` and `channel: "voice"`, including `recentHistory` for context.
-4. **Your server responds** — You process the transcript (e.g., send to your LLM) and return a response. We strongly recommend streaming NDJSON — TTS starts speaking on the first chunk.
-5. **TTS speaks the response** — Each NDJSON chunk is spoken with sub-second latency. No waiting for the full response.
-6. **Conversation continues** — The caller can interrupt at any time (barge-in). The cycle repeats naturally.
-#### Call flow (built-in AI mode)
-When `voiceMode` is `"hosted"`:
-1. **Caller dials your number** — The AI answers with your `beginMessage` (e.g., "Hello! How can I help?").
-2. **Caller speaks** — Streaming STT transcribes in real-time.
-3. **Built-in LLM generates a response** — The LLM uses your `systemPrompt` to generate a contextual response.
-4. **TTS speaks the response** — Streaming TTS speaks the response with sub-second latency.
-5. **Conversation continues** — No server or webhook involved — the platform handles everything.
-#### Voice capabilities
-Both modes share the same low-latency engine:
-| Capability          | Description                                                           |
-| ------------------- | --------------------------------------------------------------------- |
-| Streaming STT       | Real-time speech-to-text transcription                                |
-| Streaming TTS       | Sub-second text-to-speech synthesis                                   |
-| Barge-in            | Caller can interrupt the agent mid-sentence                           |
-| Backchanneling      | Natural conversational cues ("uh-huh", "right")                       |
-| Turn detection      | Smart end-of-speech detection                                         |
-| Streaming responses | Return NDJSON to start TTS on the first chunk                         |
-| DTMF digit press    | Press keypad digits to navigate IVR menus and automated phone systems |
-| Call recording       | Optional add-on — automatically records calls and provides audio URLs |
-#### Webhook response format
-For voice webhooks, your server must return a JSON object (`{...}`) telling the agent what to say. Non-object responses (numbers, strings, arrays) are ignored and the caller hears silence.
-##### Streaming response (recommended)
-Return `Content-Type: application/x-ndjson` with newline-delimited JSON chunks. TTS starts speaking on the very first chunk while your server continues processing.
-```
-{"text": "Let me check that for you.", "interim": true}
-{"text": "Your order #4521 shipped yesterday via FedEx."}
-```
-Mark interim chunks with `"interim": true` — the final chunk (without `interim`) closes the turn. Use this for tool calls, LLM token forwarding, or any time your response takes more than ~1 second.
-##### Simple response
-Return a single JSON object for instant replies where no processing delay is expected.
-```json
-{ "text": "How can I help you?" }
-```
-##### Response fields
-| Field     | Type    | Description                                                                                                                                               |
-| --------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `text`    | string  | Text to speak to the caller                                                                                                                               |
-| `hangup`  | boolean | Set to `true` to end the call after speaking                                                                                                              |
-| `action`  | string  | `"transfer"` to cold-transfer the call (requires `transferNumber` on the agent), `"hangup"` to end it                                                     |
-| `digits`  | string  | DTMF digits to press on the keypad (e.g. `"1"`, `"123"`, `"1*#"`). Used to navigate IVR menus and automated phone systems. Aliases: `press_digit`, `dtmf` |
-| `interim` | boolean | NDJSON only — marks a chunk as interim (TTS speaks it but the turn stays open)                                                                            |
-> **Warning: Webhook timeout** — Voice webhook requests have a **30-second default timeout** (configurable from 5–120 seconds per webhook via the `timeout` field). If your server doesn't start responding in time, the request is cancelled and the caller hears silence for that turn. This is especially important when your webhook calls external APIs or runs LLM tool calls — always stream an interim chunk immediately so the caller hears something while you process.
-#### Example: streaming handler (Python / FastAPI)
-```python
-from fastapi.responses import StreamingResponse
-import json, openai
-@app.post('/webhook')
-async def handle_voice(payload: dict):
-    if payload['channel'] != 'voice':
-        return Response(status_code=200)
-    history = payload.get('recentHistory', [])
-    context = "\n".join([
-        f"{'Customer' if h['direction'] == 'inbound' else 'Agent'}: {h['content']}"
-        for h in history
-    ])
-    async def generate():
-        yield json.dumps({"text": "One moment, let me check.", "interim": True}) + "\n"
-        stream = openai.chat.completions.create(
-            model="gpt-4",
-            stream=True,
-            messages=[
-                {"role": "system", "content": "You are a helpful phone agent."},
-                {"role": "user", "content": f"Conversation:\n{context}\n\nRespond."}
-            ]
-        )
-        full = ""
-        for chunk in stream:
-            delta = chunk.choices[0].delta.content or ""
-            full += delta
-        yield json.dumps({"text": full}) + "\n"
-    return StreamingResponse(generate(), media_type="application/x-ndjson")
-```
-#### Example: streaming handler (Node.js / Express)
-```javascript
-const OpenAI = require('openai');
-const openai = new OpenAI();
-app.post('/webhook', express.json(), async (req, res) => {
-  if (req.body.channel !== 'voice') return res.status(200).send('OK');
-  const history = req.body.recentHistory || [];
-  const context = history
-    .map(h => `${h.direction === 'inbound' ? 'Customer' : 'Agent'}: ${h.content}`)
-    .join('\n');
-  res.setHeader('Content-Type', 'application/x-ndjson');
-  res.write(JSON.stringify({ text: 'One moment, let me check.', interim: true }) + '\n');
-  const stream = await openai.chat.completions.create({
-    model: 'gpt-4',
-    stream: true,
-    messages: [
-      { role: 'system', content: 'You are a helpful phone agent.' },
-      { role: 'user', content: `Conversation:\n${context}\n\nRespond.` }
-    ]
-  });
-  let full = '';
-  for await (const chunk of stream) {
-    full += chunk.choices[0]?.delta?.content || '';
-  }
-  res.write(JSON.stringify({ text: full }) + '\n');
-  res.end();
-});
-```
-#### Example: tool-calling handler (Python / Flask)
-When your agent needs to call external APIs (databases, calendars, CRM, etc.) during a voice call, always stream an interim filler response first. This prevents the caller from hearing silence while your tools run.
-The pattern is: **stream an interim acknowledgement immediately → run your tools → stream the final answer**.
-```python
-from flask import Flask, request, Response
-import json, anthropic, os
-app = Flask(__name__)
-client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
-TOOLS = [
-    {
-        "name": "get_todays_calendar",
-        "description": "Get the user's calendar events for today.",
-        "input_schema": {"type": "object", "properties": {}, "required": []},
-    },
-    {
-        "name": "search_orders",
-        "description": "Look up a customer's recent orders.",
-        "input_schema": {
-            "type": "object",
-            "properties": {"query": {"type": "string"}},
-            "required": ["query"],
-        },
-    },
-]
-TOOL_HANDLERS = {
-    "get_todays_calendar": lambda args: fetch_calendar_events(),
-    "search_orders": lambda args: search_order_db(args["query"]),
-}
-def run_tool_call(user_message: str, history: list) -> str:
-    """Run Claude with tools and return the final text response."""
-    messages = [{"role": "user", "content": user_message}]
-    for _ in range(5):  # max tool-call iterations
-        response = client.messages.create(
-            model="claude-haiku-4-5-20251001",
-            max_tokens=256,
-            system="You are a helpful phone assistant. Keep responses to 2-3 sentences.",
-            tools=TOOLS,
-            messages=messages,
-        )
-        if response.stop_reason == "tool_use":
-            messages.append({"role": "assistant", "content": response.content})
-            tool_results = []
-            for block in response.content:
-                if block.type == "tool_use":
-                    handler = TOOL_HANDLERS.get(block.name)
-                    result = handler(block.input) if handler else "Unknown tool"
-                    tool_results.append({
-                        "type": "tool_result",
-                        "tool_use_id": block.id,
-                        "content": result,
-                    })
-            messages.append({"role": "user", "content": tool_results})
-        else:
-            return " ".join(b.text for b in response.content if hasattr(b, "text"))
-    return "Sorry, I'm having trouble processing that."
-@app.post("/webhook")
-def webhook():
-    payload = request.json
-    if payload.get("channel") != "voice":
-        return "OK", 200
-    transcript = payload["data"].get("transcript", "")
-    history = payload.get("recentHistory", [])
-    def generate():
-        # Immediately tell the caller we're working on it
-        yield json.dumps({"text": "Let me check on that.", "interim": True}) + "\n"
-        # Now run the slow tool calls (LLM + external APIs)
-        try:
-            answer = run_tool_call(transcript, history)
-        except Exception:
-            answer = "Sorry, I ran into a problem. Could you try again?"
-        yield json.dumps({"text": answer}) + "\n"
-    return Response(generate(), content_type="application/x-ndjson")
-```
-#### Example: tool-calling handler (Node.js / Express)
-```javascript
-const express = require("express");
-const Anthropic = require("@anthropic-ai/sdk");
-const app = express();
-app.use(express.json());
-const client = new Anthropic();
-const tools = [
-  {
-    name: "get_todays_calendar",
-    description: "Get the user's calendar events for today.",
-    input_schema: { type: "object", properties: {}, required: [] },
-  },
-  {
-    name: "search_orders",
-    description: "Look up a customer's recent orders.",
-    input_schema: {
-      type: "object",
-      properties: { query: { type: "string" } },
-      required: ["query"],
-    },
-  },
-];
-const toolHandlers = {
-  get_todays_calendar: (args) => fetchCalendarEvents(),
-  search_orders: (args) => searchOrderDb(args.query),
-};
-async function runToolCall(userMessage) {
-  const messages = [{ role: "user", content: userMessage }];
-  for (let i = 0; i < 5; i++) {
-    const response = await client.messages.create({
-      model: "claude-haiku-4-5-20251001",
-      max_tokens: 256,
-      system: "You are a helpful phone assistant. Keep responses to 2-3 sentences.",
-      tools,
-      messages,
-    });
-    if (response.stop_reason === "tool_use") {
-      messages.push({ role: "assistant", content: response.content });
-      const toolResults = [];
-      for (const block of response.content) {
-        if (block.type === "tool_use") {
-          const handler = toolHandlers[block.name];
-          const result = handler ? await handler(block.input) : "Unknown tool";
-          toolResults.push({ type: "tool_result", tool_use_id: block.id, content: result });
-        }
-      }
-      messages.push({ role: "user", content: toolResults });
-    } else {
-      return response.content
-        .filter((b) => b.type === "text")
-        .map((b) => b.text)
-        .join(" ");
-    }
-  }
-  return "Sorry, I'm having trouble processing that.";
-}
-app.post("/webhook", async (req, res) => {
-  if (req.body.channel !== "voice") return res.status(200).send("OK");
-  const transcript = req.body.data?.transcript || "";
-  res.setHeader("Content-Type", "application/x-ndjson");
-  // Immediately tell the caller we're working on it
-  res.write(JSON.stringify({ text: "Let me check on that.", interim: true }) + "\n");
-  // Now run the slow tool calls (LLM + external APIs)
-  try {
-    const answer = await runToolCall(transcript);
-    res.write(JSON.stringify({ text: answer }) + "\n");
-  } catch (err) {
-    res.write(JSON.stringify({ text: "Sorry, I ran into a problem." }) + "\n");
-  }
-  res.end();
-});
-app.listen(3000);
-```
-> **Tip: Why interim chunks matter for tool calls** — Without the interim chunk, the caller hears dead silence while your LLM decides which tool to call, the external API responds, and the LLM summarises the result. With streaming, they hear "Let me check on that" within milliseconds — just like a human assistant would.
----
-#### Troubleshooting voice calls
-##### Caller hears silence after speaking
-**Your webhook is too slow or not responding.** Voice webhooks have a 30-second default timeout (configurable per webhook from 5–120 seconds). If your server doesn't respond in time, the turn is dropped and the caller hears nothing.
-**Fix:** Always stream an interim NDJSON chunk immediately (e.g. `{"text": "One moment.", "interim": true}`) before doing any slow work. This buys you time while keeping the caller engaged.
-Common causes:
-- LLM tool calls that take too long (external API latency + LLM processing)
-- Cold starts on serverless platforms (Lambda, Cloud Functions)
-- Webhook URL is unreachable or returning errors
-##### Caller hears silence after the greeting
-**Your webhook isn't configured or isn't returning a valid JSON object.** Voice responses must be a JSON object (`{...}`). Non-object responses (strings, arrays, numbers) are ignored.
-**Fix:** Verify your webhook is returning `{"text": "..."}`. Use `POST /v1/webhooks/test` to confirm your endpoint is reachable and responding correctly.
-##### Response is cut off or sounds garbled
-**You're sending the entire response as a single large chunk.** Long responses in a single chunk can cause TTS delays.
-**Fix:** Use NDJSON streaming and break responses into natural sentences. Send each sentence as an interim chunk so TTS can start speaking immediately.
-##### Agent speaks XML or code artifacts
-**Your LLM is including tool-call markup in its response.** Some LLMs emit `<function_call>` or similar tags.
-**Fix:** Strip non-speech content from your LLM output before returning it. AgentPhone removes common patterns automatically, but your webhook should clean responses to be safe.
-##### Webhook works for SMS but not voice
-**You're returning a `200 OK` with no body, or a non-JSON response for voice.** SMS webhooks only need a `200` status — voice webhooks must return a JSON object with a `text` field.
-**Fix:** Check the `channel` field in the webhook payload. For `"voice"`, always return `{"text": "..."}`. For `"sms"`, a `200 OK` is sufficient.
----
-#### Call recording
-Call recording is an optional add-on that saves audio recordings of your voice calls. When enabled, completed calls include a `recordingUrl` field with a link to the audio file.
-| Field                | Type           | Description                                                                                                                               |
-| -------------------- | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
-| `recordingUrl`       | string or null | URL to the call recording audio file. Only populated when the recording add-on is enabled.                                                |
-| `recordingAvailable` | boolean        | Whether a recording exists for this call. Can be `true` even when `recordingUrl` is null (recording exists but the add-on is not active). |
-Enable recording from the **Billing** page in the dashboard. See [Usage & Billing](https://docs.agentphone.to/documentation/guides/usage#call-recording-add-on) for pricing.
-> **Note:** Recordings are captured automatically for all calls while the add-on is active. If you disable the add-on, existing recordings are preserved but `recordingUrl` will be null until you re-enable it.
----
-#### List All Calls
-List all calls for this project.
-```
-GET /v1/calls
-```
-**Query parameters:**
-| Parameter   | Type    | Required | Default | Description                                                 |
-| ----------- | ------- | -------- | ------- | ----------------------------------------------------------- |
-| `limit`     | integer | No       | 20      | Number of results to return (max 100)                       |
-| `offset`    | integer | No       | 0       | Number of results to skip (min 0)                           |
-| `status`    | string  | No       | —       | Filter by status: `completed`, `in-progress`, `failed`      |
-| `direction` | string  | No       | —       | Filter by direction: `inbound`, `outbound`, `web`           |
-| `search`    | string  | No       | —       | Search by phone number (matches `fromNumber` or `toNumber`) |
-```bash
-curl -X GET "https://api.agentphone.to/v1/calls?limit=10&offset=0" \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-**Response:**
-```json
-{
-  "data": [
-    {
-      "id": "call_ghi012",
-      "agentId": "agt_abc123",
-      "phoneNumberId": "num_xyz789",
-      "phoneNumber": "+15551234567",
-      "fromNumber": "+15559876543",
-      "toNumber": "+15551234567",
-      "direction": "inbound",
-      "status": "completed",
-      "startedAt": "2025-01-15T14:00:00Z",
-      "endedAt": "2025-01-15T14:05:30Z",
-      "durationSeconds": 330,
-      "lastTranscriptSnippet": "Thank you for calling, goodbye!",
-      "recordingUrl": "https://api.twilio.com/2010-04-01/.../Recordings/RE...",
-      "recordingAvailable": true
-    }
-  ],
-  "hasMore": false,
-  "total": 1
-}
-```
-#### Get Call Details
-Get details of a specific call, including its full transcript.
-```
-GET /v1/calls/{call_id}
-```
-```bash
-curl -X GET "https://api.agentphone.to/v1/calls/call_ghi012" \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-**Response:**
-```json
-{
-  "id": "call_ghi012",
-  "agentId": "agt_abc123",
-  "phoneNumberId": "num_xyz789",
-  "phoneNumber": "+15551234567",
-  "fromNumber": "+15559876543",
-  "toNumber": "+15551234567",
-  "direction": "inbound",
-  "status": "completed",
-  "startedAt": "2025-01-15T14:00:00Z",
-  "endedAt": "2025-01-15T14:05:30Z",
-  "durationSeconds": 330,
-  "recordingUrl": "https://api.twilio.com/2010-04-01/.../Recordings/RE...",
-  "recordingAvailable": true,
-  "transcripts": [
-    {
-      "id": "tr_001",
-      "transcript": "Hello! Thanks for calling Acme Corp. How can I help you today?",
-      "confidence": 0.95,
-      "response": "Sure! Could you please provide your order number?",
-      "createdAt": "2025-01-15T14:00:05Z"
-    },
-    {
-      "id": "tr_002",
-      "transcript": "Hi, I'd like to check the status of my order.",
-      "confidence": 0.92,
-      "response": "Of course! Let me look that up for you.",
-      "createdAt": "2025-01-15T14:00:15Z"
-    }
-  ]
-}
-```
-#### Create Outbound Call
-Initiate an outbound voice call from one of your agent's phone numbers. The agent's first assigned phone number is used as the caller ID.
-```
-POST /v1/calls
-```
-**Request body:**
-| Field             | Type           | Required | Description                                                                                    |
-| ----------------- | -------------- | -------- | ---------------------------------------------------------------------------------------------- |
-| `agentId`         | string         | Yes      | The agent that will handle the call. Its first assigned phone number is used as caller ID.     |
-| `toNumber`        | string         | Yes      | The phone number to call (E.164 format, e.g., `"+15559876543"`)                                |
-| `initialGreeting` | string or null | No       | Optional greeting to speak when the recipient answers                                          |
-| `voice`           | string         | No       | Voice to use for speaking (default: `"Polly.Amy"`)                                             |
-| `systemPrompt`    | string or null | No       | When provided, uses a built-in LLM for the conversation instead of forwarding to your webhook. |
-```bash
-curl -X POST "https://api.agentphone.to/v1/calls" \
-  -H "Authorization: Bearer YOUR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "agentId": "agt_abc123",
-    "toNumber": "+15559876543",
-    "initialGreeting": "Hi, this is Acme Corp calling about your recent order.",
-    "systemPrompt": "You are a friendly support agent from Acme Corp."
-  }'
-```
-#### List Calls for a Number
-List all calls associated with a specific phone number.
-```
-GET /v1/numbers/{number_id}/calls
-```
-```bash
-curl -X GET "https://api.agentphone.to/v1/numbers/num_xyz789/calls?limit=10" \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-#### Get Call Transcript
-```bash
-curl https://api.agentphone.to/v1/calls/CALL_ID/transcript \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
----
-### Messages & Conversations
-#### Get Messages for a Number
-```bash
-curl "https://api.agentphone.to/v1/numbers/NUMBER_ID/messages?limit=50" \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-| Parameter | Type | Required | Default | Description |
-|-----------|------|----------|---------|-------------|
-| `limit` | `number` | No | 50 | Max results (1-200) |
-**Response:**
-```json
-{
-  "data": [
-    {
-      "id": "msg_abc123",
-      "from": "+14155559999",
-      "to": "+14155551234",
-      "body": "Hey, what time is my appointment?",
-      "direction": "inbound",
-      "status": "received",
-      "receivedAt": "2025-01-15T10:40:00.000Z"
-    }
-  ],
-  "total": 1
-}
-```
-#### List Conversations
-Conversations are threaded SMS exchanges between your number and an external contact. Each unique phone number pair creates one conversation.
-```bash
-curl "https://api.agentphone.to/v1/conversations?limit=20" \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-| Parameter | Type | Required | Default | Description |
-|-----------|------|----------|---------|-------------|
-| `limit` | `number` | No | 20 | Max results (1-100) |
-**Response:**
-```json
-{
-  "data": [
-    {
-      "id": "conv_xyz",
-      "phoneNumber": "+14155551234",
-      "participant": "+14155559999",
-      "messageCount": 5,
-      "lastMessageAt": "2025-01-15T10:45:00.000Z",
-      "lastMessagePreview": "Sounds good, see you then!"
-    }
-  ],
-  "total": 1
-}
-```
-#### Get a Conversation
-Get a specific conversation with its message history.
-```bash
-curl "https://api.agentphone.to/v1/conversations/CONVERSATION_ID?messageLimit=50" \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-| Parameter | Type | Required | Default | Description |
-|-----------|------|----------|---------|-------------|
-| `messageLimit` | `number` | No | 50 | Max messages to return (1-100) |
----
-### Webhooks (Project-Level)
-The project-level webhook receives events for **all agents** unless overridden by an agent-specific webhook.
-#### Set Webhook
-```bash
-curl -X POST https://api.agentphone.to/v1/webhooks \
-  -H "Authorization: Bearer YOUR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "url": "https://your-server.com/webhook",
-    "contextLimit": 10
-  }'
-```
-| Field | Type | Required | Default | Description |
-|-------|------|----------|---------|-------------|
-| `url` | `string` | Yes | — | Publicly accessible HTTPS URL |
-| `contextLimit` | `number` | No | 10 | Number of recent messages to include in webhook payloads (0-50) |
-**Response:**
-```json
-{
-  "id": "wh_abc123",
-  "url": "https://your-server.com/webhook",
-  "secret": "whsec_...",
-  "status": "active",
-  "contextLimit": 10
-}
-```
-**Save the `secret`** — use it to verify webhook signatures on your server.
-#### Get Webhook
-```bash
-curl https://api.agentphone.to/v1/webhooks \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-#### Delete Webhook
-Agents with their own webhook are not affected.
-```bash
-curl -X DELETE https://api.agentphone.to/v1/webhooks \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-#### Get Webhook Delivery Stats
-```bash
-curl "https://api.agentphone.to/v1/webhooks/deliveries/stats?hours=24" \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-#### List Recent Deliveries
-```bash
-curl "https://api.agentphone.to/v1/webhooks/deliveries?limit=10" \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-#### Test Webhook
-Send a test event to verify your webhook is working.
-```bash
-curl -X POST https://api.agentphone.to/v1/webhooks/test \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
----
-### Webhooks (Per-Agent)
-Route a specific agent's events to a different URL. When set, the agent's events go here instead of the project-level webhook.
-#### Set Agent Webhook
-```bash
-curl -X POST https://api.agentphone.to/v1/agents/AGENT_ID/webhook \
-  -H "Authorization: Bearer YOUR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "url": "https://your-server.com/agent-webhook",
-    "contextLimit": 5
-  }'
-```
-#### Get Agent Webhook
-```bash
-curl https://api.agentphone.to/v1/agents/AGENT_ID/webhook \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-#### Delete Agent Webhook
-Events fall back to the project-level webhook.
-```bash
-curl -X DELETE https://api.agentphone.to/v1/agents/AGENT_ID/webhook \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-#### Test Agent Webhook
-```bash
-curl -X POST https://api.agentphone.to/v1/agents/AGENT_ID/webhook/test \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
----
-### Usage & Limits
-```bash
-curl https://api.agentphone.to/v1/usage \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-**Response:**
-```json
-{
-  "plan": { "name": "free", "numberLimit": 1 },
-  "numbers": { "used": 1, "limit": 1 },
-  "stats": {
-    "messagesLast30d": 42,
-    "callsLast30d": 15,
-    "minutesLast30d": 67
-  }
-}
-```
-#### Daily Breakdown
-```bash
-curl "https://api.agentphone.to/v1/usage/daily?days=7" \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
-#### Monthly Breakdown
-```bash
-curl "https://api.agentphone.to/v1/usage/monthly?months=3" \
-  -H "Authorization: Bearer YOUR_API_KEY"
-```
----
-## Webhook Events
-When a call or message comes in, AgentPhone sends an HTTP POST to your webhook URL with the event payload.
-### Event types
-| Event | Description |
-|-------|-------------|
-| `call.started` | An inbound call has started |
-| `call.ended` | A call has ended (includes transcript) |
-| `agent.message` | Real-time voice transcript or SMS received — check `channel` field |
-| `message.received` | An SMS was received on your number |
-| `message.sent` | An outbound SMS was delivered |
-### Voice vs SMS webhooks
-The `channel` field in the webhook payload tells you the event source:
-- **`channel: "voice"`** — Real-time voice call event. Your response **must** be a JSON object with a `text` field (e.g. `{"text": "Hello!"}`). Return `Content-Type: application/x-ndjson` for streaming responses. Non-object responses are ignored and the caller hears silence.
-- **`channel: "sms"`** — SMS message event. A `200 OK` status is sufficient — no response body needed.
-### Payload structure
-The webhook payload includes:
-- The full call or message object in the `data` field
-- Recent conversation context in `recentHistory` (controlled by `contextLimit`)
-- The `channel` field (`"voice"` or `"sms"`)
-- The `event` field (e.g. `"agent.message"`)
-### Webhook timeout
-Voice webhooks have a **30-second default timeout** (configurable from 5–120 seconds via the `timeout` field when creating or updating a webhook). If your server doesn't start responding in time, the caller hears silence for that turn. Always stream an interim NDJSON chunk immediately for voice webhooks.
-### Verifying signatures
-Each webhook request includes a signature header. Use the `secret` from your webhook setup to verify the payload hasn't been tampered with.
----
-## Response Format
-**Success:**
-```json
-{
-  "id": "resource_id",
-  "..."
-}
-```
-**List:**
-```json
-{
-  "data": [...],
-  "total": 42
-}
-```
-**Error:**
-```json
-{
-  "detail": "Description of what went wrong"
-}
-```
-**Common status codes:**
-| Code | Meaning |
-|------|---------|
-| `200` | Success |
-| `201` | Created |
-| `400` | Bad request (validation error, missing params) |
-| `401` | Unauthorized (missing or invalid API key) |
-| `402` | Payment required (insufficient balance) |
-| `404` | Resource not found |
-| `429` | Rate limited |
-| `500` | Server error |
----
-## Ideas: What You Can Build
-Now that your agent has a phone number, here are things you can do:
-- **Appointment scheduling** — Call businesses to book appointments on your human's behalf. Handle the back-and-forth conversation autonomously.
-- **Customer support hotline** — Set up an agent with a system prompt that knows your product. It handles inbound calls 24/7.
-- **Outbound sales calls** — Make calls to leads with a tailored pitch. Check transcripts to see how each call went.
-- **SMS notifications** — Send appointment reminders, order updates, or alerts to your users via SMS.
-- **Phone verification** — Call or text users to verify their phone numbers during signup.
-- **IVR replacement** — Replace clunky phone trees with a conversational AI that understands natural language.
-- **Meeting reminders** — Call or text participants before meetings to confirm attendance.
-- **Lead qualification** — Call inbound leads, ask qualifying questions, and log the results.
-- **Personal assistant** — Give your AI a phone number so it can handle calls and texts on your behalf — scheduling, reminders, and follow-ups.
-These are starting points. Having your own phone number means your agent can do anything a human can do over the phone, autonomously.
----
-## Additional Resources
-- [API Reference](https://docs.agentphone.to/api-reference)
-- [Official Docs](https://docs.agentphone.to)
-- [Console](https://agentphone.to)
 ## Limitations
 - Use this skill only when the task clearly matches the scope described above.
 - Do not treat the output as a substitute for environment-specific validation, testing, or expert review.