Skip to content

OpenRing 0.1.8: tested Vapi import, model picker, WhatsApp and MCP, alerts, a new dashboard

Latest

Choose a tag to compare

@elifalanrocha elifalanrocha released this 19 Nov 13:40
· 2 commits to main since this release

Changed

  • A Tools page (list, create and delete tools of every kind), evals and structured outputs written in fields instead of
    hand-typed JSON (the JSON stays one click away), one summary strip on a call instead of seven cards, and a "Needs
    attention" panel on Home: failed calls by cause, slow answers, providers an assistant needs with no key.
  • The dashboard has its own look: warm paper and warm ink instead of pure grey, soft depth and rounder corners, with the
    orange kept as the one signal. In the assistant editor the call path (transcriber, model, voice) is drawn as three
    cards joined by a line, each with its provider's logo; Save sits in a bar that stays on screen and says "Unsaved
    changes"; saving keeps you on the assistant and confirms with "Saved" (so you can edit, save and test).

Added

  • Alerts (OpenRing's own): set alertWebhook (Settings, Alerts, or PATCH /settings/alerts) and a call that ends because
    a provider or line failed is reported to that address within half a minute, once, with no caller number or words in it.
    The address goes through the same guard as every address a person typed; nothing is retried.
  • Importing an account now makes its assistants work with the keys this server has: a transcriber or model whose
    provider has no key here is swapped for a provider that has one (the original kept in importedTranscriber /
    importedModel, and said in the import report). Assistants that already work are left alone.
  • The mcp tool: an assistant can use the tools of an MCP server (Streamable HTTP). At the start of a call OpenRing asks
    the server for its tools and gives each to the model; the server's address goes through the same guard as every address
    a person typed, answers are capped, and errors never carry the address or headers. A server that can't be reached costs
    its tools, not the call.
  • Three more of Vapi's server messages, sent only to an assistant that lists them in serverMessages: model-output
    (the model's text as it writes), voice-input (the text handed to the voice) and transfer-update (a transfer to a
    number, or a handoff between assistants).
  • A guide, Migrating from Vapi: importing an account, reading the report, what changes
    (Vapi's own voices become Kokoro), pointing code and phone webhooks at OpenRing, and what is not here.
  • Choosing a model, as in Vapi's editor: Choose opens one list of every provider's models to search, filter by
    provider and sort by name, low latency or low cost per minute. Each model shows its time to the first word (from
    OpenRing's own test calls or this server's calls; Measure times one now, with a few tokens of your account) and
    what it costs a minute at list prices; models whose provider has no key here say so. GET /models and
    POST /models/measure. There is no "intelligence" score: OpenRing has no honest source for one.
  • WhatsApp calls with no third party, through WaCalls (beta, unofficial, self-hosted,
    never tried on a real call): a phone number with "provider": "wacalls" and a wacallsSession answers and places
    WhatsApp voice calls with an assistant, the audio going to a WaCalls server of your own (WACALLS_URL) over a WebRTC data
    channel, with no per-minute fee. WaCalls has no login: keep it on a trusted network. Tested against a pretend WaCalls
    speaking its protocol, as read from its source.
  • More providers, each with its logo. Models: SambaNova, Nebius, Novita AI, Qwen (Alibaba Cloud), Inception (Mercury),
    Moonshot (Kimi), NVIDIA NIM and Hugging Face (sambanova, nebius, novita, qwen, inception, moonshot,
    nvidia, huggingface). Transcribers: OpenAI, Groq (Whisper) and Gradium. Voices: MiniMax (with its group ID),
    Resemble AI, Gradium, Async and Speechify. None needs a new dependency. Built and checked in tests only, not yet on
    a real call.
  • Versions of an assistant and traffic split between them (OpenRing's own API): POST /assistant/{id}/version keeps
    the assistant as it is, a version can be restored, and trafficPlan gives saved versions a percentage of the calls.
    Each call records which one answered (assistantVersion), and the Traffic tab compares them: calls, success rate
    (from analysisPlan) and cost per call. Tested on simulated calls only.
  • Sign in with Hugging Face on the Providers page, with no OAuth app to create: when the server has an https
    PUBLIC_URL it is its own client (a Client ID Metadata Document at /.well-known/oauth-cimd). The token becomes the
    key calls use and is refreshed before it runs out; one that can't be refreshed disconnects the provider. Checked
    against a pretend Hugging Face only, not a real sign-in.
  • The assistant editor no longer shows the "Caller" box before the transcriber.
  • Presets in the assistant editor, as on Vapi: Balanced, High intelligence, Ultra fast and Cost saver set the whole
    stack in one click, each with its estimated cost per minute (list prices) and its time to answer where OpenRing has
    measured it (its own test calls, or this server's calls), and the keys it still needs (GET /assistant/presets).
  • The assistant editor has tabs, as on Vapi: Assistant, Advanced (limits, recording, memory, analysis, voicemail,
    report URL), Tools (link saved tools), Logs (this assistant's calls), Traffic (calls a day, phone and browser),
    Test (talk to it, run evals against it) and JSON. GET /call?assistantId= lists one assistant's calls.
  • A new identity, in the family of Real Valor, which makes OpenRing: a symbol of two half-discs of a ring pulled apart
    (one ring, two voices), black, white and greys with OpenRing's orange as its one signal, and the Archivo typeface. The
    dashboard takes it: flat surfaces with 1px rules, corners of 4 to 6px, no shadows. Logo files in docs/assets/brand/.
  • Speech-to-speech (beta): with {"provider": "openai", "model": "gpt-realtime"} the model hears and speaks itself, with no
    transcriber or voice of the call's own and only OPENAI_API_KEY needed. Its voice comes from voice when it is an OpenAI one.
  • Calls share the voice activity and turn detectors' models instead of loading them again each: a new call no longer
    stalls the others for about 300 ms, and 20 calls at once take 368 MB instead of 956 MB.
  • scripts/load_test.py measures how many calls at once a computer takes (about 20 per process on a 2018 laptop; the
    numbers are in docs/deploy.md).
  • openring mcp: an MCP server, so an AI agent can place a call through OpenRing and read the transcript.
  • Callers that are AI agents ("I'm an AI assistant calling on behalf of…", in English, Portuguese and Spanish) are
    noticed, the call is marked callerIsAI, and the model is told to answer briefly and exactly (aiCallerPlan).
  • The dashboard moves more smoothly: switching assistants keeps the list still and brings in only the editor, cost and
    latency bars grow into place, and controls answer the pointer; all of it off with reduced motion.
  • A webhook log: each call's page lists the messages it sent to your server, with the answer and the time each took
    (GET /call/{id}/webhooks).
  • Vapi's startSpeakingPlan.waitSeconds, stopSpeakingPlan.voiceSeconds and numWords, and keypadInputPlan: keys the
    caller presses reach the model as text. Settings with no equivalent yet are named in the call's warnings.
  • Write an assistant from a description: on a new assistant, a model you connected drafts its name, greeting and
    system prompt (POST /assistant/draft, OpenRing's own); nothing is saved until you save it.
  • Recorded messages (beta, Twilio): upload a WAV or MP3 (POST /announcement) and give it to an assistant
    (announcement.audioId); the call plays it and hangs up, costing only the line. A campaign plays it to a whole list.
  • On-call escalations (beta, Twilio, /escalation, an Escalations page): call a list in order until someone presses
    the confirmation key, round the list up to 5 times.
  • Assistants open beside their list: each with its model's logo and its three layers, the first one opened at once
    with its cost, answer time and setup. "Instructions" is now "System prompt", the name the field has everywhere else.
    Pages come in with a short, quiet movement (none with reduced motion).
  • The dashboard serves its own typeface (Archivo, SIL OFL), so it no longer calls Google Fonts.
  • Vapi's live server messages, in Vapi's shape: speech-update (who started or stopped speaking, with the turn),
    user-interrupted (the caller talked over the assistant) and hang (the caller has waited 5 seconds for an answer),
    sent by default as on Vapi; and transcript, partial and final, for an assistant that lists it in serverMessages
    (transcript[transcriptType="final"] for the final ones alone). A server that falls behind loses partial
    transcripts, never anything else. Tested on simulated calls only.
  • Calls over WhatsApp (beta, unofficial, never tried on a real call): a phone number with "provider": "wavoip" and a
    wavoipToken answers and places WhatsApp voice calls with an assistant through Wavoip, with no public URL. The token is
    never shown by the API; the number says how its device is (wavoipStatus). WhatsApp may ban a number used through an
    unofficial client: the docs and the dashboard say so.
  • voice.speed, as on Vapi, on ElevenLabs, OpenAI, Deepgram and Kokoro voices, kept within what each takes (a
    warning says when a speed was limited or a voice can't change it), with a slider in the assistant editor.
  • The assistant editor opens with what the assistant costs per minute and how long it takes to answer, layer by layer:
    measured on its own last calls, or the cost estimated from list prices until it has some
    (GET /assistant/{id}/profile, OpenRing's own).
  • A new server starts with an assistant to talk to, made once from what costs nothing: Whisper and Kokoro on this
    computer, and Ollama's model when Ollama is running (Groq's otherwise, which needs its free key).
  • The dashboard's menu folds to its icons (a button by the logo, remembered on this browser) and scrolls without
    showing a bar.
  • PATCH /call/{id} renames a call and DELETE /call/{id} deletes it for good, record, transcript and recording, as
    on Vapi; a call still going on is refused.
  • scripts/vapi_sdk_check.py runs Vapi's official Python SDK against an OpenRing server: 34 of the 38 calls it tries
    pass on vapi_server_sdk 3.0.0 (the list is in docs/api.md).
  • Memory per caller (beta, OpenRing's own field): with "callerMemory": {"enabled": true} an assistant is given, when a
    phone call starts, what was said on that number's last calls with it (calls, 3 by default, and maxCharacters,
    4000). It reads the transcripts already on your server: nothing else is stored, no model is asked and nothing is
    charged, and a deleted call is forgotten. Off by default, because a caller ID can be faked. A "Remember callers" box
    in the assistant editor; the call records which calls it was given in rememberedCallIds.
  • Structured outputs, as on Vapi (/structured-output, /structured-output/run): reusable data pulled out of every
    call of the assistants that link them (artifactPlan.structuredOutputIds, or the output's assistantIds), by a
    model or a pattern, into artifact.structuredOutputs; run on past calls, with a preview. An Outputs page and
    boxes in the assistant editor; the import brings them over from Vapi. Checked on a real call with Groq.
  • Evals, as on Vapi (/eval, /eval/run): a chat you script for an assistant, with checks on what it answers (exact
    words, a pattern, the tool calls and their arguments, or a judge model's pass or fail) and Vapi's continuePlan.
    Runs go on in the background against an assistant or a squad. The dashboard has an Evals page. Checked against
    Groq: a booking assistant called its tool with the right arguments and a judge model passed its confirmation.
  • After the call, Vapi's analysisPlan: the assistant's own model writes a summary, pulls data out in the shape of a
    JSON schema and judges on a rubric whether the call succeeded; in the call, the end-of-call report and the call page,
    with its tokens and cost in costBreakdown.analysisCostBreakdown. Only for assistants that ask (it spends your
    model's tokens; Vapi analyzes every call by default). Checked on a real call with Groq.
  • Background sound, Vapi's backgroundSound: "office" (distant chatter and keyboards, made by OpenRing from no
    recording, so a transcriber makes no words of it) or an audio file's URL (WAV, MP3, OGG, FLAC, up to 10 MB, looped at
    the same quiet level), on phone and browser calls alike. Off unless asked: Vapi plays the office on phone calls by
    default. The assistant editor has it under Voice, with the voice's language (voice.language, which ElevenLabs now
    takes too).
  • scripts/smoke_call.py: a real call on your own computer, with your provider keys (Deepgram, Groq and Kokoro by
    default, another voice with --voice), over a simulated phone line and a synthesized caller. It checks twelve things,
    from the caller's words reaching the model to the end-of-call report, costs a few cents and calls nobody.

Fixed

  • Callers lost words: a sentence said after a short pause could be left out of the model's answer, or vanish, seen on
    real calls (Deepgram, Groq, ElevenLabs and Kokoro, with scripts/smoke_call.py). Four causes:
    • every message to the assistant's server built a new HTTPS client, which reads the whole CA bundle: each one froze
      every live call for about 0.2 s. One TLS context, built at startup, now serves all of OpenRing's requests (server
      messages, tools, provider APIs). Turns end sooner too: 0.21 s from silence to end of turn, down from about 0.55 s;
    • the turn ended with the earlier sentence's transcript when its last words came just after the next sentence began:
      a transcript the transcriber finishes within 0.3 s of the caller speaking again now counts with what came before;
    • a turn that starts interrupts, and Pipecat dropped a transcript still waiting in its queue: transcripts are now
      never dropped by an interruption;
    • the transcriber can send part of a sentence while the caller is still saying it, and the turn ended on that part:
      a transcript sent before the caller stopped now waits up to half a second for the rest (which comes 0.1 to 0.2 s
      after the stop on the test calls).
  • A turn after the caller interrupted the assistant had no latency recorded (Pipecat 1.15 times it from the connection);
    each turn's time now comes from its own measure, and latency averages count only the turns where a stage was measured.
  • When an ElevenLabs voice gives no audio, the call's endedReason says the most common cause: a free account can't use
    library voices through the API.