dial-autogen 0.10.0__tar.gz

dial_autogen-0.10.0/.gitignore

@@ -0,0 +1,5 @@
+.venv/
+dist/
+__pycache__/
+*.egg-info/
+.pytest_cache/

dial_autogen-0.10.0/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: dial-autogen
+Version: 0.10.0
+Summary: Official Dial AutoGen tools — phone numbers, SMS, OTP, and voice calls for Microsoft AutoGen agents
+Requires-Python: >=3.11
+Requires-Dist: autogen-agentchat>=0.4
+Requires-Dist: autogen-core>=0.4
+Requires-Dist: dial-sdk
+Description-Content-Type: text/markdown
+
+# dial-autogen
+
+Official Dial tools for [Microsoft AutoGen](https://microsoft.github.io/autogen/) — give an
+AutoGen agent the ability to send SMS, receive OTP codes, and place AI voice calls through
+[Dial](https://getdial.ai). Agents automating signups and web tasks get a real phone identity.
+
+It's the AutoGen sibling of [`dial-langchain`](https://pypi.org/project/dial-langchain/) and
+[`dial-crewai`](https://pypi.org/project/dial-crewai/): each tool is an
+[`autogen_core.tools.FunctionTool`](https://microsoft.github.io/autogen/stable//user-guide/core-user-guide/components/tools.html)
+wrapping the [`dial-sdk`](https://pypi.org/project/dial-sdk/) client. It adds nothing to the REST
+contract — it just shapes Dial's operations into AutoGen tools.
+
+> Targeting Microsoft's newer **Agent Framework** instead of AutoGen? Use
+> [`dial-agentframework`](https://pypi.org/project/dial-agentframework/).
+
+## Install
+
+```bash
+pip install dial-autogen
+```
+
+This pulls in `dial-sdk` and `autogen-agentchat`.
+
+## Give the tools to an agent
+
+Build one `DialClient`, pass it to `dial_tools`, and hand the result to an
+`AssistantAgent`. Every tool shares that one client — a single connection pool for the
+whole agent session — and you own its lifecycle (`await client.close()` when done):
+
+```python
+from autogen_agentchat.agents import AssistantAgent
+from autogen_ext.models.openai import AzureOpenAIChatCompletionClient
+from dial_sdk import DialClient, DialConfig
+from dial_autogen import dial_tools
+
+dial = DialClient(DialConfig(api_key="sk_live_..."))  # close with `await dial.close()`
+
+model_client = AzureOpenAIChatCompletionClient(
+    azure_deployment="gpt-4o",
+    model="gpt-4o",
+    api_version="2024-10-21",
+    azure_endpoint="https://<your-resource>.openai.azure.com/",
+)
+
+agent = AssistantAgent(
+    name="phone_agent",
+    model_client=model_client,
+    tools=dial_tools(dial),
+    system_message="You operate the team's Dial phone number for SMS, OTP, and voice calls.",
+)
+```
+
+`DialConfig` also takes an optional `base_url` to target a non-default deployment.
+
+### Or pick individual tools
+
+Each builder takes the shared `DialClient` and returns one `FunctionTool`:
+
+```python
+from dial_autogen import send_message_tool, wait_for_message_tool
+
+tools = [
+    send_message_tool(dial),
+    wait_for_message_tool(dial),
+]
+```
+
+## Available tools
+
+Each builder takes your shared `DialClient`:
+
+| Builder | Tool name | Action |
+|---|---|---|
+| `list_numbers_tool` | `list_numbers` | List your phone numbers |
+| `purchase_number_tool` | `purchase_number` | Provision a new number (billable) |
+| `set_number_properties_tool` | `set_number_properties` | Update a number's nickname / inbound instruction |
+| `send_message_tool` | `send_message` | Send an SMS (optionally MMS) |
+| `list_messages_tool` | `list_messages` | List recent messages |
+| `make_call_tool` | `make_call` | Place an AI voice call |
+| `list_calls_tool` | `list_calls` | List recent calls |
+| `get_call_tool` | `get_call` | Fetch one call by id |
+| `get_billing_tool` | `get_billing` | Credit balance, subscription, per-number mode |
+| `wait_for_message_tool` | `wait_for_message` | Block until the next inbound SMS arrives, or time out |
+
+## OTP flow
+
+The point of phone identity for an agent: send a code and read the reply.
+`wait_for_message` blocks until the next inbound SMS arrives, so an agent can:
+
+1. trigger a signup that texts a code to your Dial number,
+2. call `wait_for_message` to read the inbound code,
+3. enter it back into the signup form.
+
+See [`examples/signup_autogen.ipynb`](./examples/signup_autogen.ipynb) for a runnable agent.
+
+## Notes
+
+- AutoGen runs tools in an async loop, so these tools are **async-native** — no
+  async→sync bridge (the one difference from the CrewAI sibling).
+- `send_message` is a write action and **isn't idempotent** — a re-invoke after a
+  failure can send a duplicate. `make_call` accepts an `idempotency_key`.
+- `wait_for_message` is backed by Dial's **presence-based** event stream — for
+  durable, at-least-once delivery, register a
+  [webhook](https://docs.getdial.ai/documentation/platform/webhooks).
+
+See the [AutoGen integration docs](https://docs.getdial.ai/documentation/sdks/autogen)
+for the full guide.

dial_autogen-0.10.0/README.md

@@ -0,0 +1,107 @@
+# dial-autogen
+
+Official Dial tools for [Microsoft AutoGen](https://microsoft.github.io/autogen/) — give an
+AutoGen agent the ability to send SMS, receive OTP codes, and place AI voice calls through
+[Dial](https://getdial.ai). Agents automating signups and web tasks get a real phone identity.
+
+It's the AutoGen sibling of [`dial-langchain`](https://pypi.org/project/dial-langchain/) and
+[`dial-crewai`](https://pypi.org/project/dial-crewai/): each tool is an
+[`autogen_core.tools.FunctionTool`](https://microsoft.github.io/autogen/stable//user-guide/core-user-guide/components/tools.html)
+wrapping the [`dial-sdk`](https://pypi.org/project/dial-sdk/) client. It adds nothing to the REST
+contract — it just shapes Dial's operations into AutoGen tools.
+
+> Targeting Microsoft's newer **Agent Framework** instead of AutoGen? Use
+> [`dial-agentframework`](https://pypi.org/project/dial-agentframework/).
+
+## Install
+
+```bash
+pip install dial-autogen
+```
+
+This pulls in `dial-sdk` and `autogen-agentchat`.
+
+## Give the tools to an agent
+
+Build one `DialClient`, pass it to `dial_tools`, and hand the result to an
+`AssistantAgent`. Every tool shares that one client — a single connection pool for the
+whole agent session — and you own its lifecycle (`await client.close()` when done):
+
+```python
+from autogen_agentchat.agents import AssistantAgent
+from autogen_ext.models.openai import AzureOpenAIChatCompletionClient
+from dial_sdk import DialClient, DialConfig
+from dial_autogen import dial_tools
+
+dial = DialClient(DialConfig(api_key="sk_live_..."))  # close with `await dial.close()`
+
+model_client = AzureOpenAIChatCompletionClient(
+    azure_deployment="gpt-4o",
+    model="gpt-4o",
+    api_version="2024-10-21",
+    azure_endpoint="https://<your-resource>.openai.azure.com/",
+)
+
+agent = AssistantAgent(
+    name="phone_agent",
+    model_client=model_client,
+    tools=dial_tools(dial),
+    system_message="You operate the team's Dial phone number for SMS, OTP, and voice calls.",
+)
+```
+
+`DialConfig` also takes an optional `base_url` to target a non-default deployment.
+
+### Or pick individual tools
+
+Each builder takes the shared `DialClient` and returns one `FunctionTool`:
+
+```python
+from dial_autogen import send_message_tool, wait_for_message_tool
+
+tools = [
+    send_message_tool(dial),
+    wait_for_message_tool(dial),
+]
+```
+
+## Available tools
+
+Each builder takes your shared `DialClient`:
+
+| Builder | Tool name | Action |
+|---|---|---|
+| `list_numbers_tool` | `list_numbers` | List your phone numbers |
+| `purchase_number_tool` | `purchase_number` | Provision a new number (billable) |
+| `set_number_properties_tool` | `set_number_properties` | Update a number's nickname / inbound instruction |
+| `send_message_tool` | `send_message` | Send an SMS (optionally MMS) |
+| `list_messages_tool` | `list_messages` | List recent messages |
+| `make_call_tool` | `make_call` | Place an AI voice call |
+| `list_calls_tool` | `list_calls` | List recent calls |
+| `get_call_tool` | `get_call` | Fetch one call by id |
+| `get_billing_tool` | `get_billing` | Credit balance, subscription, per-number mode |
+| `wait_for_message_tool` | `wait_for_message` | Block until the next inbound SMS arrives, or time out |
+
+## OTP flow
+
+The point of phone identity for an agent: send a code and read the reply.
+`wait_for_message` blocks until the next inbound SMS arrives, so an agent can:
+
+1. trigger a signup that texts a code to your Dial number,
+2. call `wait_for_message` to read the inbound code,
+3. enter it back into the signup form.
+
+See [`examples/signup_autogen.ipynb`](./examples/signup_autogen.ipynb) for a runnable agent.
+
+## Notes
+
+- AutoGen runs tools in an async loop, so these tools are **async-native** — no
+  async→sync bridge (the one difference from the CrewAI sibling).
+- `send_message` is a write action and **isn't idempotent** — a re-invoke after a
+  failure can send a duplicate. `make_call` accepts an `idempotency_key`.
+- `wait_for_message` is backed by Dial's **presence-based** event stream — for
+  durable, at-least-once delivery, register a
+  [webhook](https://docs.getdial.ai/documentation/platform/webhooks).
+
+See the [AutoGen integration docs](https://docs.getdial.ai/documentation/sdks/autogen)
+for the full guide.

dial_autogen-0.10.0/dial_autogen/__init__.py

@@ -0,0 +1,27 @@
+from .tools import (
+    dial_tools,
+    list_numbers_tool,
+    purchase_number_tool,
+    set_number_properties_tool,
+    list_messages_tool,
+    send_message_tool,
+    list_calls_tool,
+    make_call_tool,
+    get_call_tool,
+    get_billing_tool,
+    wait_for_message_tool,
+)
+
+__all__ = [
+    "dial_tools",
+    "list_numbers_tool",
+    "purchase_number_tool",
+    "set_number_properties_tool",
+    "list_messages_tool",
+    "send_message_tool",
+    "list_calls_tool",
+    "make_call_tool",
+    "get_call_tool",
+    "get_billing_tool",
+    "wait_for_message_tool",
+]

dial_autogen-0.10.0/dial_autogen/tools.py

@@ -0,0 +1,413 @@
+"""Dial tools for Microsoft AutoGen (``autogen-agentchat`` / ``autogen-core``).
+
+Each builder takes a ``dial_sdk.DialClient`` and returns an
+``autogen_core.tools.FunctionTool`` that calls it. The client is **passed in, not
+constructed per call** — you build one ``DialClient`` and share it across every tool,
+so a whole agent session reuses a single connection pool. You own the client's
+lifecycle (call ``await client.close()`` when done).
+
+AutoGen runs tools in an async loop, so — unlike the CrewAI sibling — there is no
+async→sync bridge: every tool is a plain ``async def``.
+
+    from autogen_agentchat.agents import AssistantAgent
+    from dial_sdk import DialClient, DialConfig
+    from dial_autogen import dial_tools
+
+    client = DialClient(DialConfig(api_key="sk_live_..."))
+    agent = AssistantAgent(
+        name="phone_agent",
+        model_client=model_client,
+        tools=dial_tools(client),
+    )
+"""
+
+import asyncio
+from typing import Annotated, Optional
+
+from autogen_core.tools import FunctionTool
+from dial_sdk import (
+    DialClient,
+    MakeCallParams,
+    PurchaseNumberParams,
+    SendMessageParams,
+)
+
+
+# ── Numbers ──────────────────────────────────────────────────────────────────
+
+
+def list_numbers_tool(client: DialClient) -> FunctionTool:
+    async def list_numbers() -> str:
+        numbers = await client.list_numbers()
+        if not numbers:
+            return "No numbers found."
+        return "\n".join(
+            f"{n.id} | {n.number} | {n.country} | {n.capabilities}"
+            + (f' | "{n.nickname}"' if n.nickname else "")
+            for n in numbers
+        )
+
+    return FunctionTool(
+        list_numbers,
+        name="list_numbers",
+        description="List all available Dial phone numbers on the account.",
+    )
+
+
+def purchase_number_tool(client: DialClient) -> FunctionTool:
+    async def purchase_number(
+        inbound_instruction: Annotated[
+            str,
+            "System prompt the AI voice agent uses on inbound calls to the new number",
+        ],
+        inbound_voice_gender: Annotated[
+            Optional[str],
+            "Voice gender for inbound calls to the new number: 'male' or 'female'. "
+            "Omit to use the default female voice.",
+        ] = None,
+        area_code: Annotated[
+            Optional[str],
+            "Preferred US area code to provision in, e.g. '415'. Omit for any available "
+            "US number. Only US numbers can be provisioned at this time.",
+        ] = None,
+    ) -> str:
+        number = await client.purchase_number(
+            PurchaseNumberParams(
+                inbound_instruction=inbound_instruction,
+                area_code=area_code,
+                inbound_voice_gender=inbound_voice_gender,
+            )
+        )
+        return f"Purchased {number.number} (id: {number.id}, country: {number.country})"
+
+    return FunctionTool(
+        purchase_number,
+        name="purchase_number",
+        description="Provision (buy) a new Dial phone number. Billable.",
+    )
+
+
+def set_number_properties_tool(client: DialClient) -> FunctionTool:
+    async def set_number_properties(
+        number_id: Annotated[str, "ID of the Dial phone number to update"],
+        inbound_instruction: Annotated[
+            Optional[str], "New system prompt for inbound calls to this number"
+        ] = None,
+        inbound_voice_gender: Annotated[
+            Optional[str],
+            "Voice gender for inbound calls to this number: 'male' or 'female'. "
+            "Pass an empty string to clear it (reverts to the default, female).",
+        ] = None,
+        nickname: Annotated[
+            Optional[str],
+            "Human-readable label for the number, e.g. 'Support line'. "
+            "Pass an empty string to clear it.",
+        ] = None,
+        max_call_duration_seconds: Annotated[
+            Optional[int],
+            "Cap calls on this number to at most this many seconds, applied as a hard "
+            "ceiling to both inbound and outbound calls. The effective cap on a call is "
+            "the smallest of the per-number, account, and per-call limits.",
+        ] = None,
+    ) -> str:
+        kwargs: dict = {}
+        if inbound_instruction is not None:
+            kwargs["inbound_instruction"] = inbound_instruction
+        # Empty string clears the override (reverts to the default, female); else set it.
+        if inbound_voice_gender is not None:
+            kwargs["inbound_voice_gender"] = inbound_voice_gender or None
+        if nickname is not None:
+            kwargs["nickname"] = nickname
+        if max_call_duration_seconds is not None:
+            kwargs["max_call_duration_seconds"] = max_call_duration_seconds
+        if not kwargs:
+            return (
+                "Provide at least one of inbound_instruction, inbound_voice_gender, "
+                "nickname, or max_call_duration_seconds."
+            )
+        number = await client.set_number_properties(number_id, **kwargs)
+        nick = f' | nickname: "{number.nickname}"' if number.nickname else ""
+        return f"Updated {number.number} (id: {number.id}){nick}"
+
+    return FunctionTool(
+        set_number_properties,
+        name="set_number_properties",
+        description=(
+            "Update a Dial phone number's properties: its inbound instruction (the system "
+            "prompt its AI voice agent uses on inbound calls) and/or its nickname. "
+            "Provide at least one."
+        ),
+    )
+
+
+# ── Messages ─────────────────────────────────────────────────────────────────
+
+
+def list_messages_tool(client: DialClient) -> FunctionTool:
+    async def list_messages(
+        number_id: Annotated[
+            Optional[str], "Restrict to messages on a single owned phone number id"
+        ] = None,
+        direction: Annotated[
+            Optional[str], "Filter by direction: 'inbound' or 'outbound'"
+        ] = None,
+    ) -> str:
+        messages = await client.list_messages(number_id=number_id, direction=direction)
+        if not messages:
+            return "No messages found."
+        return "\n".join(
+            f"[{m.direction}] {m.from_} → {m.to}: {m.body[:50]}" for m in messages
+        )
+
+    return FunctionTool(
+        list_messages,
+        name="list_messages",
+        description="List recent inbound and outbound messages on the account.",
+    )
+
+
+def send_message_tool(client: DialClient) -> FunctionTool:
+    async def send_message(
+        to: Annotated[str, "Destination phone number in E.164 format, e.g. +1234567890"],
+        from_number_id: Annotated[str, "ID of the Dial phone number to send from"],
+        body: Annotated[str, "Message body text"],
+        channel: Annotated[str, "Channel to use: 'sms'"] = "sms",
+        media_urls: Annotated[
+            Optional[list[str]],
+            "Publicly reachable http(s) URLs of media to attach (MMS), max 10. "
+            "Dial downloads and re-hosts each one.",
+        ] = None,
+    ) -> str:
+        msg = await client.send_message(
+            SendMessageParams(
+                to=to,
+                from_number_id=from_number_id,
+                body=body,
+                channel=channel,
+                media=list(media_urls or []),
+            )
+        )
+        media_note = (
+            f", media: {', '.join(m.url for m in msg.media)}" if msg.media else ""
+        )
+        return f"Message sent successfully. ID: {msg.id}, status: {msg.status}{media_note}"
+
+    return FunctionTool(
+        send_message,
+        name="send_message",
+        description="Send an SMS message to a phone number, optionally with media attachments (MMS).",
+    )
+
+
+# ── Calls ────────────────────────────────────────────────────────────────────
+
+
+def list_calls_tool(client: DialClient) -> FunctionTool:
+    async def list_calls(
+        number_id: Annotated[
+            Optional[str], "Restrict to calls on a single owned phone number id"
+        ] = None,
+        direction: Annotated[
+            Optional[str], "Filter by direction: 'inbound' or 'outbound'"
+        ] = None,
+    ) -> str:
+        calls = await client.list_calls(number_id=number_id, direction=direction)
+        if not calls:
+            return "No calls found."
+        return "\n".join(
+            f"{c.id} | [{c.direction}] {c.from_} → {c.to} | "
+            f"{c.status.get('label')} | {c.duration}s"
+            for c in calls
+        )
+
+    return FunctionTool(
+        list_calls,
+        name="list_calls",
+        description="List recent inbound and outbound calls on the account.",
+    )
+
+
+def make_call_tool(client: DialClient) -> FunctionTool:
+    async def make_call(
+        to: Annotated[str, "Destination phone number in E.164 format, e.g. +1234567890"],
+        from_number_id: Annotated[str, "ID of the Dial phone number to call from"],
+        outbound_instruction: Annotated[
+            str, "System prompt for the AI voice agent during this call"
+        ],
+        language: Annotated[
+            Optional[str],
+            "BCP-47 language tag, e.g. 'en-US', 'he-IL'. Omit to auto-detect from the "
+            "destination number's country (the agent also handles en-US).",
+        ] = None,
+        voice_gender: Annotated[
+            Optional[str],
+            "Voice gender for the agent: 'male' or 'female'. Omit to use the default "
+            "female voice (the default for every language); pass 'male' to override.",
+        ] = None,
+        transfer_to: Annotated[
+            Optional[str],
+            "Forward-to number in E.164 format, e.g. +1987654321. When set, the agent "
+            "waits for a real human (riding out hold music and IVR menus) and then "
+            "cold-transfers the call to this number. Must differ from `to` and the from number.",
+        ] = None,
+        idempotency_key: Annotated[
+            Optional[str],
+            "Unique key (e.g. a UUID) making the placement idempotent: re-invoking with "
+            "the same key returns the already-placed call instead of dialing again.",
+        ] = None,
+        max_call_duration_seconds: Annotated[
+            Optional[int],
+            "Maximum duration for this call in seconds. Omit to use the account-level "
+            "or number-level cap (if any).",
+        ] = None,
+    ) -> str:
+        call = await client.make_call(
+            MakeCallParams(
+                to=to,
+                from_number_id=from_number_id,
+                outbound_instruction=outbound_instruction,
+                language=language,
+                voice_gender=voice_gender,
+                transfer_to=transfer_to,
+                idempotency_key=idempotency_key,
+                max_call_duration_seconds=max_call_duration_seconds,
+            )
+        )
+        return f"Call initiated. ID: {call.id}, state: {call.status.get('state')}"
+
+    return FunctionTool(
+        make_call,
+        name="make_call",
+        description="Initiate an AI voice call to a phone number.",
+    )
+
+
+def get_call_tool(client: DialClient) -> FunctionTool:
+    async def get_call(call_id: Annotated[str, "ID of the call to fetch"]) -> str:
+        call = await client.get_call(call_id)
+        return (
+            f"Call {call.id}: [{call.direction}] {call.from_} → {call.to} | "
+            f"state={call.status.get('state')} | label={call.status.get('label')} | "
+            f"duration={call.duration}s"
+        )
+
+    return FunctionTool(
+        get_call,
+        name="get_call",
+        description="Fetch a single call by its id, including its current status.",
+    )
+
+
+# ── Billing ──────────────────────────────────────────────────────────────────
+
+
+def get_billing_tool(client: DialClient) -> FunctionTool:
+    async def get_billing() -> str:
+        b = await client.get_billing()
+        balance = f"${b.balance_cents / 100:.2f}"
+        if b.subscription:
+            plan = (
+                f"subscribed ({b.subscription.interval}, "
+                f"{b.subscription.quantity} numbers, renews {b.subscription.period_end})"
+            )
+        else:
+            plan = "pay-as-you-go"
+        numbers = ", ".join(f"{n.number} [{n.mode}]" for n in b.numbers) or "none"
+        return f"Balance: {balance} | Plan: {plan} | Numbers: {numbers}"
+
+    return FunctionTool(
+        get_billing,
+        name="get_billing",
+        description=(
+            "Get the account's billing status: credit balance, subscription (if any), "
+            "each number's billing mode (PAYG or subscription), and recent usage."
+        ),
+    )
+
+
+# ── Events (wait-for) ────────────────────────────────────────────────────────
+
+
+def wait_for_message_tool(client: DialClient) -> FunctionTool:
+    async def wait_for_message(
+        phone_number_id: Annotated[
+            str,
+            "Optional id of the Dial phone number to wait on. If omitted, returns the "
+            "first inbound message on any number.",
+        ] = "",
+        timeout_seconds: Annotated[
+            int, "How long to wait for a message in seconds"
+        ] = 30,
+    ) -> str:
+        # Resolve the phone number id to its E.164 number so we can match the
+        # inbound event's `to` field (events carry the number, not its id).
+        target_number: Optional[str] = None
+        if phone_number_id:
+            numbers = await client.list_numbers()
+            match = next((n for n in numbers if n.id == phone_number_id), None)
+            if match is None:
+                return f"No owned number with id {phone_number_id}."
+            target_number = match.number
+
+        async def _first_message() -> Optional[dict]:
+            async with client.new_events_connection() as conn:
+                async for event in conn:
+                    if event.get("type") != "message.received":
+                        continue
+                    # Event fields live under `data` in the standardized envelope.
+                    data = event.get("data", {})
+                    if target_number and data.get("to") != target_number:
+                        continue
+                    return event
+            return None
+
+        try:
+            event = await asyncio.wait_for(_first_message(), timeout=timeout_seconds)
+        except asyncio.TimeoutError:
+            return f"No message received within {timeout_seconds}s."
+
+        if not event:
+            return f"No message received within {timeout_seconds}s."
+        data = event.get("data", {})
+        return f"Received message from {data.get('from')}: {data.get('body')}"
+
+    return FunctionTool(
+        wait_for_message,
+        name="wait_for_message",
+        description=(
+            "Wait for the next inbound SMS message and return it. Blocks until a message "
+            "arrives or the timeout elapses. Use after sending a code to await the user's reply (OTP)."
+        ),
+    )
+
+
+# ── Bundle ───────────────────────────────────────────────────────────────────
+
+
+def dial_tools(client: DialClient) -> list[FunctionTool]:
+    """Every Dial tool in one list, all sharing the given ``DialClient``.
+
+    Build one client, hand the tools to an AutoGen ``AssistantAgent``, and close the
+    client yourself when the agent is done::
+
+        from autogen_agentchat.agents import AssistantAgent
+        from dial_sdk import DialClient, DialConfig
+        from dial_autogen import dial_tools
+
+        client = DialClient(DialConfig(api_key="sk_live_..."))
+        agent = AssistantAgent(name="phone_agent", model_client=mc, tools=dial_tools(client))
+        ...
+        await client.close()
+    """
+    return [
+        list_numbers_tool(client),
+        purchase_number_tool(client),
+        set_number_properties_tool(client),
+        list_messages_tool(client),
+        send_message_tool(client),
+        list_calls_tool(client),
+        make_call_tool(client),
+        get_call_tool(client),
+        get_billing_tool(client),
+        wait_for_message_tool(client),
+    ]