callin 0.1.0__tar.gz

callin-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.pyc
+dist/
+node_modules/
+.env

callin-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Replacing Humans LLC (Callin.io)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

callin-0.1.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.5
+Name: callin
+Version: 0.1.0
+Summary: Give your AI agent a real phone line: Callin.io voice agents, calls and transcripts for Python, LangChain and CrewAI.
+Project-URL: Homepage, https://callin.io
+Project-URL: Documentation, https://support.callin.io/api-reference/introduction
+Project-URL: Source, https://github.com/callin-io/callin-agents
+Author-email: "Callin.io" <hello@callin.io>
+License: MIT
+License-File: LICENSE
+Keywords: ai agents,callin,crewai,langchain,mcp,phone calls,telephony,voice ai
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Communications :: Telephony
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.24
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.80; extra == 'crewai'
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.2; extra == 'langchain'
+Description-Content-Type: text/markdown
+
+# Callin.io for AI agents
+
+**Give your AI agent a real phone line.** Callin.io places phone calls with an AI voice agent and returns what happened: status, summary and transcript. Calls in Italian, Spanish, Portuguese, English, French, German, Dutch and Hindi, GDPR compliant, and every call discloses that it is an AI.
+
+| Use it from | How |
+|---|---|
+| Claude, ChatGPT, Cursor, VS Code, OpenAI Agents SDK | MCP server `https://claude-mcp.callin.io/mcp` (OAuth) — registry name `io.callin/callin` |
+| Python | `pip install callin` |
+| LangChain | `pip install "callin[langchain]"` → `from callin.langchain import get_callin_tools` |
+| CrewAI | `pip install "callin[crewai]"` → `from callin.crewai import CallinPlaceCallTool` |
+| Node.js | `npm i callin-sdk` |
+| OpenClaw / Claude skills | [`skills/callin-phone/SKILL.md`](skills/callin-phone/SKILL.md) |
+| n8n | community node `n8n-nodes-callin` |
+| REST | [API reference](https://support.callin.io/api-reference/introduction) · [OpenAPI](https://support.callin.io/openapi.json) |
+
+## Quickstart (Python)
+
+```python
+from callin import Callin  # env: CALLIN_API_KEY, CALLIN_AGENT_ID
+
+result = Callin().place_call(
+    "+390111234567",
+    objective="Book a table for 2 tomorrow at 20:30 under the name Rossi",
+    language="it",
+    wait=True,
+)
+print(result.status, result.summary)
+```
+
+## Quickstart (Node)
+
+```js
+import { Callin } from "callin-sdk";
+const callin = new Callin(); // env: CALLIN_API_KEY, CALLIN_AGENT_ID
+const { campaignId } = await callin.placeCall({ to: "+34911234567", objective: "Ask for the first free appointment next week", language: "es" });
+console.log(await callin.waitForCall(campaignId));
+```
+
+## How it works
+1. Create a voice agent in [app.callin.io](https://app.callin.io) with a phone number, using the [Task Caller template](task-caller-agent/prompt.md). Its id is `CALLIN_AGENT_ID`.
+2. `place_call` starts a one-contact campaign for that agent and passes `objective`, `context` and `language` as dynamic variables.
+3. `get_call_result` / `wait_for_call` returns status, summary and transcript when the call ends.
+
+## Responsible use
+Call only when your user asks you to, and only numbers they give you or public business numbers. No unsolicited marketing, no emergency numbers, no payment card data over the phone. The agent always states that it is an AI.
+
+## Pricing
+$0.16 per minute, all inclusive (telephony, language model and voice), no monthly fee. See [callin.io/pricing](https://callin.io/pricing).
+
+MIT licensed. © Replacing Humans LLC — Callin.io.

callin-0.1.0/README.md

@@ -0,0 +1,50 @@
+# Callin.io for AI agents
+
+**Give your AI agent a real phone line.** Callin.io places phone calls with an AI voice agent and returns what happened: status, summary and transcript. Calls in Italian, Spanish, Portuguese, English, French, German, Dutch and Hindi, GDPR compliant, and every call discloses that it is an AI.
+
+| Use it from | How |
+|---|---|
+| Claude, ChatGPT, Cursor, VS Code, OpenAI Agents SDK | MCP server `https://claude-mcp.callin.io/mcp` (OAuth) — registry name `io.callin/callin` |
+| Python | `pip install callin` |
+| LangChain | `pip install "callin[langchain]"` → `from callin.langchain import get_callin_tools` |
+| CrewAI | `pip install "callin[crewai]"` → `from callin.crewai import CallinPlaceCallTool` |
+| Node.js | `npm i callin-sdk` |
+| OpenClaw / Claude skills | [`skills/callin-phone/SKILL.md`](skills/callin-phone/SKILL.md) |
+| n8n | community node `n8n-nodes-callin` |
+| REST | [API reference](https://support.callin.io/api-reference/introduction) · [OpenAPI](https://support.callin.io/openapi.json) |
+
+## Quickstart (Python)
+
+```python
+from callin import Callin  # env: CALLIN_API_KEY, CALLIN_AGENT_ID
+
+result = Callin().place_call(
+    "+390111234567",
+    objective="Book a table for 2 tomorrow at 20:30 under the name Rossi",
+    language="it",
+    wait=True,
+)
+print(result.status, result.summary)
+```
+
+## Quickstart (Node)
+
+```js
+import { Callin } from "callin-sdk";
+const callin = new Callin(); // env: CALLIN_API_KEY, CALLIN_AGENT_ID
+const { campaignId } = await callin.placeCall({ to: "+34911234567", objective: "Ask for the first free appointment next week", language: "es" });
+console.log(await callin.waitForCall(campaignId));
+```
+
+## How it works
+1. Create a voice agent in [app.callin.io](https://app.callin.io) with a phone number, using the [Task Caller template](task-caller-agent/prompt.md). Its id is `CALLIN_AGENT_ID`.
+2. `place_call` starts a one-contact campaign for that agent and passes `objective`, `context` and `language` as dynamic variables.
+3. `get_call_result` / `wait_for_call` returns status, summary and transcript when the call ends.
+
+## Responsible use
+Call only when your user asks you to, and only numbers they give you or public business numbers. No unsolicited marketing, no emergency numbers, no payment card data over the phone. The agent always states that it is an AI.
+
+## Pricing
+$0.16 per minute, all inclusive (telephony, language model and voice), no monthly fee. See [callin.io/pricing](https://callin.io/pricing).
+
+MIT licensed. © Replacing Humans LLC — Callin.io.

callin-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "callin"
+version = "0.1.0"
+description = "Give your AI agent a real phone line: Callin.io voice agents, calls and transcripts for Python, LangChain and CrewAI."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Callin.io", email = "hello@callin.io" }]
+keywords = ["ai agents", "phone calls", "voice ai", "telephony", "langchain", "crewai", "mcp", "callin"]
+dependencies = ["httpx>=0.24"]
+classifiers = ["Programming Language :: Python :: 3", "License :: OSI Approved :: MIT License", "Topic :: Communications :: Telephony"]
+
+[project.optional-dependencies]
+langchain = ["langchain-core>=0.2"]
+crewai = ["crewai>=0.80"]
+
+[project.urls]
+Homepage = "https://callin.io"
+Documentation = "https://support.callin.io/api-reference/introduction"
+Source = "https://github.com/callin-io/callin-agents"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/callin"]

callin-0.1.0/src/callin/__init__.py

@@ -0,0 +1,5 @@
+"""Callin.io for AI agents: place real phone calls and read call results."""
+from .client import Callin, CallinError, CallResult
+
+__all__ = ["Callin", "CallinError", "CallResult"]
+__version__ = "0.1.0"

callin-0.1.0/src/callin/client.py

@@ -0,0 +1,238 @@
+"""Minimal client for the Callin.io public API (https://support.callin.io/api-reference/introduction).
+
+Phone calls are placed through a Callin.io voice agent that has a phone number.
+`place_call` creates a one-contact campaign for that agent and passes the call goal
+as dynamic variables (`objective`, `context`, ...), which the agent's prompt uses.
+"""
+from __future__ import annotations
+
+import os
+import time
+import uuid
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+import httpx
+
+DEFAULT_BASE_URL = "https://api.callin.io/api"
+FINAL_STATUSES = {"completed", "done", "ended", "failed", "no-answer", "no_answer", "busy", "voicemail", "canceled", "cancelled", "error"}
+
+
+class CallinError(RuntimeError):
+    """Raised when the Callin.io API returns an error."""
+
+    def __init__(self, message: str, status: Optional[int] = None, details: Any = None):
+        super().__init__(message)
+        self.status = status
+        self.details = details
+
+
+@dataclass
+class CallResult:
+    """Outcome of a phone call placed with `Callin.place_call`."""
+
+    campaign_id: str
+    status: str
+    finished: bool
+    to: str
+    call_id: Optional[str] = None
+    conversation_id: Optional[str] = None
+    duration_seconds: Optional[int] = None
+    summary: Optional[str] = None
+    transcript: Optional[str] = None
+    voicemail: Optional[bool] = None
+    error: Optional[str] = None
+    raw: Dict[str, Any] = field(default_factory=dict, repr=False)
+
+    def to_dict(self) -> Dict[str, Any]:
+        d = {k: v for k, v in self.__dict__.items() if k != "raw"}
+        return d
+
+
+class Callin:
+    """Client for the Callin.io public API.
+
+    Args:
+        api_key: Callin.io API key. Defaults to the ``CALLIN_API_KEY`` environment variable.
+        agent_id: Default voice agent used by :meth:`place_call`. Defaults to ``CALLIN_AGENT_ID``.
+        base_url: API base URL.
+    """
+
+    def __init__(self, api_key: Optional[str] = None, agent_id: Optional[str] = None,
+                 base_url: str = DEFAULT_BASE_URL, timeout: float = 30.0):
+        self.api_key = api_key or os.environ.get("CALLIN_API_KEY")
+        if not self.api_key:
+            raise CallinError("Missing API key: pass api_key= or set CALLIN_API_KEY")
+        self.agent_id = agent_id or os.environ.get("CALLIN_AGENT_ID")
+        self._http = httpx.Client(base_url=base_url.rstrip("/"), timeout=timeout,
+                                  headers={"x-api-key": self.api_key, "user-agent": "callin-python/0.1.0"})
+
+    # ---- low level -------------------------------------------------------
+    def _request(self, method: str, path: str, **kw) -> Any:
+        r = self._http.request(method, path, **kw)
+        try:
+            body = r.json()
+        except ValueError:
+            raise CallinError(f"HTTP {r.status_code}: {r.text[:200]}", r.status_code)
+        if r.status_code >= 400 or body.get("success") is False:
+            err = body.get("error") or {}
+            msg = err.get("message") if isinstance(err, dict) else str(err)
+            raise CallinError(msg or f"HTTP {r.status_code}", r.status_code, body)
+        return body.get("data", body)
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        self.close()
+
+    # ---- account & agents ------------------------------------------------
+    def me(self) -> Dict[str, Any]:
+        """Return the user id and email of the API key's account."""
+        return self._request("GET", "/public/v1/me")
+
+    def list_agents(self, search: Optional[str] = None, page_size: int = 20) -> List[Dict[str, Any]]:
+        params = {"pageSize": page_size}
+        if search:
+            params["search"] = search
+        return self._request("GET", "/public/v1/agents", params=params)
+
+    def get_agent(self, agent_id: str) -> Dict[str, Any]:
+        return self._request("GET", f"/public/v1/agents/{agent_id}")
+
+    # ---- conversations ---------------------------------------------------
+    def list_conversations(self, agent_id: Optional[str] = None, page_size: int = 20,
+                           start_after_unix: Optional[int] = None, status: Optional[str] = None) -> List[Dict[str, Any]]:
+        params: Dict[str, Any] = {"pageSize": page_size}
+        if agent_id:
+            params["agentId"] = agent_id
+        if start_after_unix:
+            params["startAfterUnix"] = start_after_unix
+        if status:
+            params["status"] = status
+        return self._request("GET", "/public/v1/conversations", params=params)
+
+    def get_conversation(self, conversation_id: str) -> Dict[str, Any]:
+        return self._request("GET", f"/public/v1/conversations/{conversation_id}")
+
+    # ---- phone calls -----------------------------------------------------
+    def place_call(self, to: str, objective: str, *, context: str = "", language: str = "",
+                   agent_id: Optional[str] = None, contact_name: str = "",
+                   variables: Optional[Dict[str, Any]] = None, wait: bool = False,
+                   timeout_seconds: int = 600, poll_seconds: int = 10) -> CallResult:
+        """Place a phone call to ``to`` (E.164, e.g. "+390111234567") with a goal.
+
+        The goal and context are passed to the voice agent as dynamic variables
+        ``objective``, ``context`` and ``language``. Use an agent whose prompt
+        includes ``{{objective}}`` and ``{{context}}`` (see the "Task Caller" template).
+
+        With ``wait=True`` the method blocks until the call ends and returns the
+        summary and transcript; otherwise call :meth:`get_call_result` later.
+        """
+        agent = agent_id or self.agent_id
+        if not agent:
+            raise CallinError("Missing agent: pass agent_id= or set CALLIN_AGENT_ID")
+        if not to.startswith("+"):
+            raise CallinError("Phone number must be in E.164 format, e.g. +390111234567")
+        contact: Dict[str, Any] = {"phoneNumber": to, "objective": objective}
+        if contact_name:
+            contact["name"] = contact_name
+        if context:
+            contact["context"] = context
+        if language:
+            contact["language"] = language
+        for k, v in (variables or {}).items():
+            contact[k] = v
+        name = f"agent-call {time.strftime('%Y-%m-%d %H:%M:%S')} {uuid.uuid4().hex[:6]}"
+        camp = self._request("POST", "/public/v1/campaigns",
+                             json={"name": name, "agentId": agent, "contacts": [contact], "launch": True})
+        result = CallResult(campaign_id=camp.get("campaignId"), status=camp.get("status") or "queued",
+                            finished=False, to=to, raw={"campaign": camp})
+        if wait:
+            return self.wait_for_call(result.campaign_id, timeout_seconds=timeout_seconds, poll_seconds=poll_seconds)
+        return result
+
+    def get_call_result(self, campaign_id: str) -> CallResult:
+        """Return the current status and, once finished, the summary and transcript of a call."""
+        camp = self._request("GET", f"/public/v1/campaigns/{campaign_id}")
+        calls = self._request("GET", f"/public/v1/campaigns/{campaign_id}/calls", params={"pageSize": 5})
+        to = ""
+        contacts = camp.get("contacts") or []
+        if contacts:
+            to = contacts[0].get("phoneNumber", "")
+        if not calls:
+            cstatus = (camp.get("status") or "queued").lower()
+            res = CallResult(campaign_id=campaign_id, status=cstatus, finished=cstatus in FINAL_STATUSES,
+                             to=to, raw={"campaign": camp})
+            if res.finished:
+                created = (camp.get("metadata") or {}).get("createdAt")
+                conv = self._find_conversation(camp.get("agentId"), {"contactNumber": to, "startedAt": created})
+                if conv:
+                    self._fill(res, conv)
+            return res
+        call = calls[0]
+        status = (call.get("status") or "").lower() or "in_progress"
+        res = CallResult(campaign_id=campaign_id, status=status, finished=status in FINAL_STATUSES, to=to,
+                         call_id=call.get("callId"), duration_seconds=call.get("durationSeconds"),
+                         error=call.get("errorMessage") or None, raw={"campaign": camp, "call": call})
+        if res.finished:
+            conv = self._find_conversation(camp.get("agentId"), call)
+            if conv:
+                self._fill(res, conv)
+        return res
+
+    @staticmethod
+    def _fill(res: "CallResult", conv: Dict[str, Any]) -> None:
+        res.conversation_id = conv.get("conversationId")
+        res.summary = conv.get("summary")
+        res.transcript = conv.get("transcript")
+        res.voicemail = conv.get("voiceMailDetected")
+        res.duration_seconds = res.duration_seconds or conv.get("conversationDuration")
+        res.raw["conversation"] = conv
+
+    def wait_for_call(self, campaign_id: str, timeout_seconds: int = 600, poll_seconds: int = 10) -> CallResult:
+        deadline = time.time() + timeout_seconds
+        res = self.get_call_result(campaign_id)
+        while not res.finished and time.time() < deadline:
+            time.sleep(poll_seconds)
+            res = self.get_call_result(campaign_id)
+        return res
+
+    def _find_conversation(self, agent_id: Optional[str], call: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        call_id = call.get("callId")
+        if call_id:
+            try:
+                conv = self.get_conversation(call_id)
+                conv.setdefault("conversationId", call_id)
+                return conv
+            except CallinError:
+                pass
+        started = call.get("startedAt")
+        after = None
+        if started:
+            try:
+                from datetime import datetime
+                after = int(datetime.fromisoformat(started.replace("Z", "+00:00")).timestamp()) - 120
+            except ValueError:
+                after = None
+        number = (call.get("contactNumber") or "").replace(" ", "")
+        convs = self.list_conversations(agent_id=agent_id, page_size=20, start_after_unix=after)
+        match = None
+        if number:
+            match = next((c for c in convs if number in (c.get("contactNumber") or "") or number in (c.get("callerNumber") or "")), None)
+        if match is None and after:
+            # A dedicated "task caller" agent places one call per campaign: take the first outbound call after launch.
+            outbound = [c for c in convs if (c.get("direction") or "outbound") == "outbound" and (c.get("startTimeUnix") or 0) >= after]
+            outbound.sort(key=lambda c: c.get("startTimeUnix") or 0)
+            match = outbound[0] if outbound else None
+        if match is None:
+            return None
+        try:
+            conv = self.get_conversation(match["conversationId"])
+            conv.setdefault("conversationId", match["conversationId"])
+            return conv
+        except CallinError:
+            return match

callin-0.1.0/src/callin/crewai.py

@@ -0,0 +1,48 @@
+"""CrewAI tools for Callin.io. Install with: pip install "callin[crewai]"."""
+from __future__ import annotations
+
+import json
+from typing import Optional, Type
+
+from crewai.tools import BaseTool
+from pydantic import BaseModel, Field
+
+from .client import Callin
+
+
+class _PlaceCallInput(BaseModel):
+    to: str = Field(..., description="Phone number in E.164 format, e.g. +390111234567")
+    objective: str = Field(..., description="What the call must achieve, in plain language")
+    context: str = Field("", description="Facts the caller may share")
+    language: str = Field("", description='Language code for the call, e.g. "it", "es", "pt", "en"')
+
+
+class CallinPlaceCallTool(BaseTool):
+    name: str = "callin_place_call"
+    description: str = ("Place a real phone call with an AI voice agent that discloses it is an AI. "
+                        "Returns campaign_id; use callin_get_call_result to read the outcome.")
+    args_schema: Type[BaseModel] = _PlaceCallInput
+    client: Optional[Callin] = None
+
+    model_config = {"arbitrary_types_allowed": True}
+
+    def _run(self, to: str, objective: str, context: str = "", language: str = "") -> str:
+        c = self.client or Callin()
+        return json.dumps(c.place_call(to=to, objective=objective, context=context, language=language).to_dict())
+
+
+class _ResultInput(BaseModel):
+    campaign_id: str = Field(..., description="campaign_id returned by callin_place_call")
+
+
+class CallinGetCallResultTool(BaseTool):
+    name: str = "callin_get_call_result"
+    description: str = "Get the status, summary and transcript of a call placed with callin_place_call."
+    args_schema: Type[BaseModel] = _ResultInput
+    client: Optional[Callin] = None
+
+    model_config = {"arbitrary_types_allowed": True}
+
+    def _run(self, campaign_id: str) -> str:
+        c = self.client or Callin()
+        return json.dumps(c.get_call_result(campaign_id).to_dict())

callin-0.1.0/src/callin/langchain.py

@@ -0,0 +1,44 @@
+"""LangChain tools for Callin.io. Install with: pip install "callin[langchain]"."""
+from __future__ import annotations
+
+import json
+from typing import List, Optional
+
+from langchain_core.tools import BaseTool, tool
+
+from .client import Callin
+
+
+def get_callin_tools(client: Optional[Callin] = None) -> List[BaseTool]:
+    """Return LangChain tools that let an agent place phone calls and read results."""
+    c = client or Callin()
+
+    @tool("callin_place_call")
+    def place_call(to: str, objective: str, context: str = "", language: str = "") -> str:
+        """Place a real phone call with an AI voice agent.
+
+        Args:
+            to: Phone number in E.164 format, e.g. +390111234567.
+            objective: What the call must achieve, in plain language
+                (e.g. "Book a table for 2 tomorrow at 20:30 under the name Rossi").
+            context: Facts the caller may share (names, order numbers, callback number).
+            language: Language code for the call, e.g. "it", "es", "pt", "en".
+        Returns a JSON string with campaign_id and status. The call is asynchronous:
+        use callin_get_call_result with the campaign_id to read the outcome.
+        The voice agent always discloses that it is an AI assistant.
+        """
+        r = c.place_call(to=to, objective=objective, context=context, language=language)
+        return json.dumps(r.to_dict())
+
+    @tool("callin_get_call_result")
+    def get_call_result(campaign_id: str) -> str:
+        """Get the status of a phone call placed with callin_place_call and, when it has
+        finished, its summary and transcript. Returns a JSON string."""
+        return json.dumps(c.get_call_result(campaign_id).to_dict())
+
+    @tool("callin_list_recent_calls")
+    def list_recent_calls(limit: int = 10) -> str:
+        """List recent calls handled by your Callin.io voice agents, with summaries. Returns JSON."""
+        return json.dumps(c.list_conversations(page_size=limit))
+
+    return [place_call, get_call_result, list_recent_calls]