⏳ This skill is pending AI review.
Scores will appear once the review pipeline completes.
channel-extension
Use when adding a new messaging channel to Tel-Agent or changing an existing one — a transport under api/channels/, its official extension manifest, its settings card, tests, health and docs. Covers the file checklist, the two inbound shapes (dial-out and the public door), the credential and signature rules that are not negotiable, the declarative setup descriptor the generic card draws from, and the test shape every channel ships with.
Choose how to use this skill
You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.
1. Native installer
This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.
Do not guess an installer command or replace an existing version without reviewing the diff.
2. Complete package recommended
Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.
No complete ProSkills package is published for this listing yet.3. Prompt-only
Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.
Need only the instruction file?
Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.
No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.
// RATINGS
Not yet listed on ClawHub or SkillsMP
// README
AI phone assistant
Connect any phone line to any AI model. Self-hosted, bring your own keys.
tel-agent.com · maintained by Dpro GmbH, Vienna
What it is
Tel-Agent is an open-source gateway that sits between a phone line and an AI agent.
A call arrives over SIP. Tel-Agent checks the caller against your routing rules and either passes it through to a human, blocks it, or hands it to an AI agent. The agent speaks with the caller in real time, can invoke tools — transfer the call, take a message, check a calendar, call any HTTP endpoint — and every call is recorded, transcribed, and searchable.
It runs on your own hardware, on your own LAN, with your own API keys.
The same agent handles phone calls and answers on web chat, SMS, email, WhatsApp, Telegram, Messenger, Instagram, Discord and Slack — connected with your own credentials from each platform, never a shared application of ours. The official channel scope now covers 24 channels including the phone, with additional channels built on the extension contract. A channel is a route a customer uses to reach you; a system you run your own business on is an integration, and those are reached through webhooks and the HTTP tool.
What it is not
- Not a PBX replacement. It connects to your existing PBX (3CX, Asterisk, FreePBX) as an extension.
- Not a workflow automation platform. Webhooks and a generic HTTP tool reach n8n and Home Assistant, which do that job better. A channel is where the conversation happens; an integration is a system the agent acts on. We own the first and reach the second through the HTTP tool.
- Not a CRM.
- Not analog-capable. Bridge an analog line with an ATA; Tel-Agent only speaks SIP.
Why it exists
Well-funded closed products already do "AI receptionist for business". What does not exist is a good open, self-hosted one — where you own the recordings, choose the models, and decide which callers ever reach the AI at all.
Project status
Alpha. Native installers and container images are available today. Choose a platform on the download page, or get the packages from the
releases page: a Windows
installer, macOS packages for Apple Silicon and Intel, DEB and RPM packages for Linux,
and a docker-compose.release.yml that pulls the published images. The installers are
unsigned while code signing is not yet configured, so the operating system will ask
once before it runs.
What works now. A conversation is answered end to end: the reply streams token by token, can be interrupted mid-sentence, is stored, and raises a notification so a person knows someone wrote in. The phone implementation includes streaming speech recognition and synthesis, interruption handling, caller-ID routing, and stored call transcripts through the SIP/LiveKit transport. Twilio integration handles SMS with customer-owned credentials. The core messaging channels are wired — web chat, WhatsApp, Telegram, Messenger, Instagram, Discord, Slack, email and SMS — and the dashboard serves them from a real API: sign-in and the account flows, home, the conversation archive, the notification tray, contacts, assistants, knowledge, the catalogue, apps, numbers, routing rul
// HOW IT'S BUILT
// FILES
2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.
.claude/skills/channel-extension/SKILL.md7.8 KBupstream ↗
--- name: channel-extension description: Use when adding a new messaging channel to Tel-Agent or changing an existing one — a transport under api/channels/, its official extension manifest, its settings card, tests, health and docs. Covers the file checklist, the two inbound shapes (dial-out and the public door), the credential and signature rules that are not negotiable, the declarative setup descriptor the generic card draws from, and the test shape every channel ships with. --- # Building a channel extension You are adding a messaging channel to Tel-Agent. A channel is a route a **customer** uses to reach a business — someone is typing on the other end. If nobody outside the business is on the other end, it is an integration, not a channel, and it is reached through the HTTP tool instead (Rule 5 in `CLAUDE.md`). Do not build it here. **Read first, in this order:** `CLAUDE.md` (the contract), `docs/SPEC.md` §B9 (secrets) and §B13 (channels), then `api/channels/discord.py` end to end. Discord is the model every channel copies: a dial-out transport with a supervisor loop, an answering policy, storage with dedup, and delivery-before-storage. For a channel that receives webhooks, also read `api/channels/meta_chat.py` and `api/routes/meta_chat_channels.py` — that is the public door, and its guards are the whole of this product's exposed surface. Write everything from the platform's **official documentation** and from the shape of the existing modules. Write it fresh. Never paste code from another product into this repository, never name another product anywhere in it, and never add a runtime dependency — `httpx`, `websockets`, `cryptography` and the standard library cover every platform we ship. ## What a channel consists of One kind, one transport module, one manifest, one descriptor, one test file. In order: | # | Path | What goes there | |---|---|---| | 1 | `api/channels/<kind>.py` | The transport. Module surface below. | | 2 | `api/extensions/builtin/<kind>.py` | `MANIFEST` + `register(context)`. Copy the Discord one; change slug, name, description. Category `channels`, origin `official`, scopes `conversations.write`, `messages.read`, `messages.write`, hooks `message.received`, ui_slots `conversation.detail`. | | 3 | `api/extensions/builtin/__init__.py` | Append the module to `BUILTIN`. | | 4 | `api/models/conversation.py` | The kind is already in `CHANNEL_KINDS` (one migration added every kind of this wave). If yours is not, add it **and** an Alembic revision that widens the `channel_kind` CHECK constraint — `tests/test_migrations.py` runs it on SQLite and PostgreSQL. | | 5 | `api/channels/generic.py` | Add the module's import path to `_DECLARED`. The registry imports it on first read; that is what serves its card and its routes. | | 6 | `api/main.py` | Dial-out channels: append `transport.loop(sessionmaker)` to `background`. Door channels: nothing — the generic public route dispatches by kind. | | 7 | `tests/test_<kind>_channel.py` | The test file. Shape below. | | 8 | `web/components/brands/marks.tsx` + `source/<kind>.svg` | The mark, when the platform has a logo. Record the source and licence in `web/components/brands/README.md`. A channel with no owner (SMS, IRC) gets a drawn glyph in `web/components/shell/channel-mark.tsx`. | | 9 | `web/app/[locale]/settings/settings.tsx` | Add the kind to `GENERIC_CHANNELS`. The card draws itself from the descriptor. | | 10 | `locales/en/web.json` | The display name under `"channels"`. Other languages follow through the translation pipeline; do not touch thirty-four files. | | 11 | `docs/SPEC.md` §B13, `README.md` icon row, `docs/brand/channels/` | One row, one icon, one table line. | ## The transport module surface Every module exposes the same names, so the generic route, the health rollup and the tests can treat them alike. Signatures are the ones `api/channels/discord.py` has; keep them. ```python KIND = "<kind>" SETUP = Setup(...) # the descriptor, see below INBOUND = "dial_out" # or "door" def make_client() -> httpx.AsyncClient: ... # tests monkeypatch this async def probe(client, credentials: dict[str, str]) -> str: ... # "Test connection". Returns the identity the platform reports (bot name, number, # account) — the card shows it. Raises ChannelRefused on a bad credential. async def send_text(client, credentials, target: str, text: str) -> None: ... def message_text(event, identity) -> str | None: ... # the answering policy: None = ignore async def ingest(db, channel, event) -> int | None: ... # store one inbound line; None when it was a duplicate or not for us async def respond(sessionmaker, channel_id: int, message_id: int) -> None: ... def schedule_reply(sessionmaker, channel_id: int, message_id: int) -> None: ... # optional def credentials_changed(channel_id: int) -> None: ... # What the module is told after the operator writes this channel's fields, so it can # drop anything it cached on the strength of the old ones — an access token bought # with a secret that has just been replaced would otherwise keep working until it # expired, which is a rotation that did not take effect. A module that caches nothing # declares nothing; `api/routes/generic_channel.py` calls it only when it is there. def reply_target(conversation) -> str | None: ... # The address `send_text` needs for this thread, when it is not the conversation's # own `external_id` — a room id, a thread key, a mailbox. Declare nothing and # `generic.reply_target_of` falls back to `external_id`. It is what the human # takeover route delivers to as well, so a channel that answers somewhere other # than where the customer wrote from owes this one function and nothing else. # dial-out only async def loop(sessionmaker) -> None: ... # the supervisor, reconciles every 15 s # door only async def receive(db, channel, request: Request) -> Response: ... # verify, dedup, store, schedule, acknowledge. One refusal for every failure. ``` `credentials` is the decrypted JSON of `Channel.credentials_encrypted` — a dict keyed by the descriptor's field names. Never read it on the inbound hot path for anything other than a signature check; per-channel state that every message needs lives in `settings_json`, which is plain. ### Shared helpers — use these, do not copy Discord `api/channels/generic.py` holds the half of a transport that is the same on every channel. A declarative channel writes the platform-specific half only: its descriptor, its signature check, `probe`, `send_text`, `message_text`, `ingest`, and its `receive` or `loop`. `split_text` is a line delegating to `split_on_words` below. Everything below is already written. | Helper | What it does | |---|---| | `channels()` | The registry, populated on first read. `module_for(kind)` and `dial_out_modules()` go through it, so no import order can change what an installation has. Never read `CHANNELS` directly. | | `public_url_for(request, settings)` | The address the platform called, for a signature computed over it. `PUBLIC_BASE_URL` when the installation has one, else the forwarded headers — the one place in this product where those are read, and the reasoning is in the function. The settings card builds its `webhook_url` on the same base, so the two cannot disagree. | | `conversation_for(db, channel, external_id, title=None)` | This customer's open thread, and whether it was just started. | | `store_line(db, conversation, role, text, language=None)` | One line into the transcript. | | `seen_before(conversation, kind, message_id)` | Dedup. A ring of the last 32 platform ids in `state_json[kind]`, because a platform does not retry in order. | | `announce(db, channel, conversation, message, started)` | The `conversation.started` and `message.received` hooks. | | `preview(text)` | One line of a customer's words, for a notification. | | `reply_target_of(module, conversation)` | Where a reply goes:README.mdupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
Plain-text copy, no login: /skill-bundles/dpro-at-tel-agent-claude-skills-channel-extension.md