dial-agentframework

Official Dial tools for the Microsoft Agent Framework — give a ChatAgent the ability to send SMS, receive OTP codes, and place AI voice calls through Dial. Agents automating signups and web tasks get a real phone identity.

It's the Agent Framework sibling of dial-langchain and dial-crewai: each tool is an agent_framework.FunctionTool (built with the tool decorator) wrapping the dial-sdk client. It adds nothing to the REST contract — it just shapes Dial's operations into Agent Framework tools.

Targeting the original AutoGen (autogen-agentchat) instead? Use dial-autogen.

Install

pip install dial-agentframework

This pulls in dial-sdk and agent-framework-core. The Agent Framework keeps each model provider in its own package, so also install a chat client — e.g. agent-framework-openai (below) or, for Azure OpenAI, the framework's Azure integration.

Give the tools to an agent

Build one DialClient, pass it to dial_tools, and hand the result to an Agent. 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):

from agent_framework import Agent
from agent_framework.openai import OpenAIChatClient  # pip install agent-framework-openai
from dial_sdk import DialClient, DialConfig
from dial_agentframework import dial_tools

dial = DialClient(DialConfig(api_key="sk_live_..."))  # close with `await dial.close()`

agent = Agent(
    OpenAIChatClient(),  # or an Azure OpenAI client for enterprise/Azure deployments
    name="phone_agent",
    instructions="You operate the team's Dial phone number for SMS, OTP, and voice calls.",
    tools=dial_tools(dial),
)

result = await agent.run("Text +14155550123 from pn_abc saying our table is ready.")
print(result.text)

DialConfig also takes an optional base_url to target a non-default deployment.

Azure OpenAI: install the framework's Azure integration and swap in its Azure OpenAI chat client — the Dial tools are identical regardless of which provider drives the agent.

Or pick individual tools

Each builder returns one AIFunction:

from dial_agentframework 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:

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_agentframework.ipynb for a runnable agent.

Notes

• The Agent Framework runs tools in an async loop, so these tools are async-native — no async→sync bridge.
• 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.

See the Microsoft Agent Framework integration docs for the full guide.