dial-crewai 0.10.0__tar.gz

dial_crewai-0.10.0/.gitignore

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

dial_crewai-0.10.0/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: dial-crewai
+Version: 0.10.0
+Summary: Official Dial CrewAI tools — phone numbers, SMS, OTP, and voice calls for multi-agent crews
+Requires-Python: >=3.11
+Requires-Dist: crewai>=0.80
+Requires-Dist: dial-sdk
+Description-Content-Type: text/markdown
+
+# dial-crewai
+
+Official Dial tools for [CrewAI](https://crewai.com) — give a multi-agent crew 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 CrewAI sibling of [`dial-langchain`](https://pypi.org/project/dial-langchain/):
+each tool is a `crewai.tools.BaseTool` subclass 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
+CrewAI tools.
+
+## Install
+
+```bash
+pip install dial-crewai
+```
+
+This pulls in `dial-sdk` and `crewai`.
+
+## Give the tools to a crew
+
+Build one `DialClient`, pass it to `dial_tools`, and hand the list to an agent. Every
+tool shares that one client — a single connection pool for the whole crew:
+
+```python
+from crewai import Agent, Crew, Task
+from dial_sdk import DialClient, DialConfig
+from dial_crewai import dial_tools
+
+dial = DialClient(DialConfig(api_key="sk_live_..."))
+
+phone_agent = Agent(
+    role="Phone identity agent",
+    goal="Send and receive SMS so the crew can complete phone-verified signups",
+    backstory="You operate the crew's Dial phone number.",
+    tools=dial_tools(dial),
+)
+```
+
+`DialConfig` also takes an optional `base_url` to target a non-default deployment.
+
+### Or pick individual tools
+
+```python
+from dial_crewai import SendMessageTool, WaitForMessageTool
+
+tools = [
+    SendMessageTool(client=dial),
+    WaitForMessageTool(client=dial),
+]
+```
+
+## Available tools
+
+Each tool takes your shared `DialClient` (`client=`):
+
+| Tool | Action |
+|---|---|
+| `ListNumbersTool` | List your phone numbers |
+| `PurchaseNumberTool` | Provision a new number (billable) |
+| `SetNumberPropertiesTool` | Update a number's nickname / inbound instruction |
+| `SendMessageTool` | Send an SMS (optionally MMS) |
+| `ListMessagesTool` | List recent messages |
+| `MakeCallTool` | Place an AI voice call |
+| `ListCallsTool` | List recent calls |
+| `GetCallTool` | Fetch one call by id |
+| `GetBillingTool` | Credit balance, subscription, per-number mode |
+| `WaitForMessageTool` | Block until the next inbound SMS arrives, or time out |
+
+## OTP flow
+
+The point of phone identity for a crew: send a code and read the reply.
+`WaitForMessageTool` 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 `WaitForMessageTool` to read the inbound code,
+3. enter it back into the signup form.
+
+See [`examples/signup_crew.py`](./examples/signup_crew.py) for a runnable crew.
+
+## Notes
+
+- The `dial-sdk` client is async; these tools are **sync-first** (`_run`) with an
+  async→sync bridge, and also expose `_arun` for async crews. The shared client's
+  requests run on a single background event loop, so the connection pool is reused
+  across calls; a sync crew needn't close the client explicitly.
+- `SendMessageTool` is a write action and **isn't idempotent** — a re-invoke after a
+  failure can send a duplicate. `MakeCallTool` accepts an `idempotency_key`.
+- `WaitForMessageTool` 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 [CrewAI integration docs](https://docs.getdial.ai/documentation/sdks/crewai)
+for the full guide.

dial_crewai-0.10.0/README.md

@@ -0,0 +1,95 @@
+# dial-crewai
+
+Official Dial tools for [CrewAI](https://crewai.com) — give a multi-agent crew 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 CrewAI sibling of [`dial-langchain`](https://pypi.org/project/dial-langchain/):
+each tool is a `crewai.tools.BaseTool` subclass 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
+CrewAI tools.
+
+## Install
+
+```bash
+pip install dial-crewai
+```
+
+This pulls in `dial-sdk` and `crewai`.
+
+## Give the tools to a crew
+
+Build one `DialClient`, pass it to `dial_tools`, and hand the list to an agent. Every
+tool shares that one client — a single connection pool for the whole crew:
+
+```python
+from crewai import Agent, Crew, Task
+from dial_sdk import DialClient, DialConfig
+from dial_crewai import dial_tools
+
+dial = DialClient(DialConfig(api_key="sk_live_..."))
+
+phone_agent = Agent(
+    role="Phone identity agent",
+    goal="Send and receive SMS so the crew can complete phone-verified signups",
+    backstory="You operate the crew's Dial phone number.",
+    tools=dial_tools(dial),
+)
+```
+
+`DialConfig` also takes an optional `base_url` to target a non-default deployment.
+
+### Or pick individual tools
+
+```python
+from dial_crewai import SendMessageTool, WaitForMessageTool
+
+tools = [
+    SendMessageTool(client=dial),
+    WaitForMessageTool(client=dial),
+]
+```
+
+## Available tools
+
+Each tool takes your shared `DialClient` (`client=`):
+
+| Tool | Action |
+|---|---|
+| `ListNumbersTool` | List your phone numbers |
+| `PurchaseNumberTool` | Provision a new number (billable) |
+| `SetNumberPropertiesTool` | Update a number's nickname / inbound instruction |
+| `SendMessageTool` | Send an SMS (optionally MMS) |
+| `ListMessagesTool` | List recent messages |
+| `MakeCallTool` | Place an AI voice call |
+| `ListCallsTool` | List recent calls |
+| `GetCallTool` | Fetch one call by id |
+| `GetBillingTool` | Credit balance, subscription, per-number mode |
+| `WaitForMessageTool` | Block until the next inbound SMS arrives, or time out |
+
+## OTP flow
+
+The point of phone identity for a crew: send a code and read the reply.
+`WaitForMessageTool` 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 `WaitForMessageTool` to read the inbound code,
+3. enter it back into the signup form.
+
+See [`examples/signup_crew.py`](./examples/signup_crew.py) for a runnable crew.
+
+## Notes
+
+- The `dial-sdk` client is async; these tools are **sync-first** (`_run`) with an
+  async→sync bridge, and also expose `_arun` for async crews. The shared client's
+  requests run on a single background event loop, so the connection pool is reused
+  across calls; a sync crew needn't close the client explicitly.
+- `SendMessageTool` is a write action and **isn't idempotent** — a re-invoke after a
+  failure can send a duplicate. `MakeCallTool` accepts an `idempotency_key`.
+- `WaitForMessageTool` 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 [CrewAI integration docs](https://docs.getdial.ai/documentation/sdks/crewai)
+for the full guide.

dial_crewai-0.10.0/dial_crewai/__init__.py

@@ -0,0 +1,27 @@
+from .tools import (
+    dial_tools,
+    ListNumbersTool,
+    PurchaseNumberTool,
+    SetNumberPropertiesTool,
+    ListMessagesTool,
+    SendMessageTool,
+    ListCallsTool,
+    MakeCallTool,
+    GetCallTool,
+    GetBillingTool,
+    WaitForMessageTool,
+)
+
+__all__ = [
+    "dial_tools",
+    "ListNumbersTool",
+    "PurchaseNumberTool",
+    "SetNumberPropertiesTool",
+    "ListMessagesTool",
+    "SendMessageTool",
+    "ListCallsTool",
+    "MakeCallTool",
+    "GetCallTool",
+    "GetBillingTool",
+    "WaitForMessageTool",
+]

dial_crewai-0.10.0/dial_crewai/_bridge.py

@@ -0,0 +1,43 @@
+"""Drive async ``dial-sdk`` coroutines from CrewAI's synchronous ``_run``.
+
+``dial-sdk`` is async, but CrewAI invokes tools synchronously via ``_run``. We run every
+coroutine on a single, lazily-started **background event loop** (a daemon thread) rather
+than calling ``asyncio.run`` per tool call.
+
+Why one persistent loop instead of a fresh loop per call: the tools share one
+``DialClient`` (passed in by the caller), and its underlying ``httpx.AsyncClient`` binds
+its connection pool to the event loop it first runs on. ``asyncio.run`` creates and tears
+down a new loop on every call, so a reused client would fail on the second call ("Event
+loop is closed"). Running all coroutines on one long-lived loop keeps the shared client's
+pool valid and reused across calls.
+"""
+
+import asyncio
+import threading
+from typing import Awaitable, Optional, TypeVar
+
+T = TypeVar("T")
+
+_loop: Optional[asyncio.AbstractEventLoop] = None
+_lock = threading.Lock()
+
+
+def _background_loop() -> asyncio.AbstractEventLoop:
+    """Return the shared background event loop, starting it on first use."""
+    global _loop
+    if _loop is None:
+        with _lock:
+            if _loop is None:
+                loop = asyncio.new_event_loop()
+                threading.Thread(
+                    target=loop.run_forever,
+                    name="dial-crewai",
+                    daemon=True,
+                ).start()
+                _loop = loop
+    return _loop
+
+
+def run_sync(coro: Awaitable[T]) -> T:
+    """Block the calling thread until ``coro`` completes on the background loop."""
+    return asyncio.run_coroutine_threadsafe(coro, _background_loop()).result()