OpenClaw

git clone https://github.com/PatterAI/patter-mcp
cd patter-mcp
npm install
npm run build
npm start          # Streamable HTTP on http://localhost:3000/mcp

pip install getpatter   # Python
npm install getpatter   # TypeScript

{
  gateway: {
    http: {
      endpoints: {
        chatCompletions: {
          enabled: true,
        },
      },
    },
  },
}

from getpatter import Patter, OpenClawLLM, DeepgramSTT, ElevenLabsTTS, Twilio

phone = Patter(carrier=Twilio(), phone_number="+15550001234")

# stt + tts (and no engine=) selects pipeline mode: STT -> LLM -> TTS.
agent = phone.agent(
    system_prompt="You are the after-hours receptionist. Keep replies short and spoken.",
    stt=DeepgramSTT(),
    llm=OpenClawLLM(agent="receptionist"),     # -> model "openclaw/receptionist"
    tts=ElevenLabsTTS(),
)

phone.serve(agent)

llm = OpenClawLLM(
    agent="openclaw/receptionist-roofing-ca",  # already-namespaced id passes through
    base_url="http://127.0.0.1:18789/v1",
    api_key="...",                             # or leave unset to read OPENCLAW_API_KEY
    timeout=120.0,
)

import { Patter, OpenClawLLM, DeepgramSTT, ElevenLabsTTS, Twilio } from 'getpatter';

const phone = new Patter({ carrier: new Twilio(), phoneNumber: '+15550001234' });

// stt + tts (and no engine) selects pipeline mode: STT -> LLM -> TTS.
const agent = phone.agent({
  systemPrompt: 'You are the after-hours receptionist. Keep replies short and spoken.',
  stt: new DeepgramSTT(),
  llm: new OpenClawLLM({ agent: 'receptionist' }), // -> model "openclaw/receptionist"
  tts: new ElevenLabsTTS(),
});

await phone.serve(agent);

{
  mcp: {
    servers: {
      patter: {
        url: "http://localhost:3000/mcp",
        transport: "streamable-http",
        // A blocking `make_call` runs for the WHOLE call. Set this above the
        // longest call you expect — 600 s (10 min), not the low default.
        timeout: 600,
        toolFilter: {
          // Scope to the phone-path tools. The voice flow does not need
          // `configure_inbound` or `get_metrics` — leave them out.
          include: [
            "make_call",
            "call_third_party",
            "get_calls",
            "get_transcript",
            "end_call",
          ],
        },
      },
    },
  },
}

{
  mcp: {
    servers: {
      patter: {
        command: "node",
        args: ["/absolute/path/to/patter-mcp/dist/index.js", "--stdio"],
        timeout: 120,
        toolFilter: {
          include: [
            "make_call",
            "call_third_party",
            "get_calls",
            "get_transcript",
            "end_call",
          ],
        },
      },
    },
  },
}

{
  "tool": "make_call",
  "arguments": {
    "to": "+15555550100",
    "wait": true,
    "objective": "Ask whether they have openings this Friday afternoon."
  }
}

{
  gateway: {
    http: {
      endpoints: {
        chatCompletions: {
          enabled: true,
        },
      },
    },
  },
}

from getpatter import ConsultConfig

agent = phone.agent(
    engine=...,                       # Realtime recommended — reassurance works there
    system_prompt="You are the after-hours receptionist...",
    consult=ConsultConfig.openclaw("receptionist"),
)

import { openclawConsult } from 'getpatter';

const agent = phone.agent({
  engine: ...,
  systemPrompt: 'You are the after-hours receptionist...',
  consult: openclawConsult('receptionist'),
});

# Per-client agent targeting — the voice path only ever names the receptionist.
RECEPTIONIST_AGENT = "openclaw/receptionist-roofing-ca"   # roofing contractor, CA
# RECEPTIONIST_AGENT = "openclaw/receptionist-homeauto-fl"  # home-automation, FL

# adapter.py — forwards Patter consult requests to ONE scoped OpenClaw agent
from fastapi import FastAPI, Request
import httpx

app = FastAPI()

OPENCLAW_URL = "http://127.0.0.1:18789/v1/chat/completions"
GATEWAY_TOKEN = "..."  # read from the environment in production, never hardcode

# Pin the explicit, least-privileged receptionist agent — never the default/master.
RECEPTIONIST_AGENT = "openclaw/receptionist-roofing-ca"

# Give the consult HTTP request its own ceiling, above the in-call work it triggers.
# 75–90 s covers a 30–60 s D-Tools lookup / browser-automation step plus margin.
CONSULT_HTTP_TIMEOUT_S = 90.0


@app.post("/consult")
async def consult(req: Request):
    body = await req.json()
    payload = {
        "model": RECEPTIONIST_AGENT,
        "messages": [{"role": "user", "content": body["request"]}],
        # One OpenClaw session per call gives multi-turn continuity. (Confirm the
        # exact session-key field your OpenClaw build expects — the OpenAI `user`
        # field or an `x-openclaw-session-key` header — against the OpenClaw docs.)
        "user": body.get("call_id") or "patter-call",
    }
    headers = {"Authorization": f"Bearer {GATEWAY_TOKEN}"}
    # Pass the caller id so the receptionist can prefetch the customer record.
    if body.get("caller"):
        headers["X-Patter-Caller"] = body["caller"]
    async with httpx.AsyncClient(timeout=CONSULT_HTTP_TIMEOUT_S) as client:
        resp = await client.post(OPENCLAW_URL, json=payload, headers=headers)
        resp.raise_for_status()
        content = resp.json()["choices"][0]["message"]["content"]
    # Return a trimmed, spoken-ready string — not a raw API dump. A long reply
    # bloats the voice context and slows the next turn.
    reply = content.strip()
    if len(reply) > 600:
        reply = reply[:600].rsplit(".", 1)[0] + "."
    return {"reply": reply}

from getpatter import Patter, ConsultConfig

phone = Patter(carrier=...)

agent = phone.agent(
    system_prompt=(
        "You are the after-hours receptionist. If the caller asks about an "
        "appointment, availability, or anything needing the customer record, "
        "say a brief 'let me check on that, one moment' and then consult the "
        "back-office agent."
    ),
    consult=ConsultConfig(
        url="https://adapter.example.com/consult",
        # Above the worst-case OpenClaw turn (e.g. a 60 s browser-automation step).
        timeout_s=90.0,
    ),
)

phone.serve(agent)

import { Patter } from 'getpatter';

const phone = new Patter({ carrier: /* ... */ });

const agent = phone.agent({
  systemPrompt:
    "You are the after-hours receptionist. If the caller asks about an " +
    "appointment, availability, or anything needing the customer record, " +
    "say a brief 'let me check on that, one moment' and then consult the " +
    'back-office agent.',
  consult: {
    url: 'https://adapter.example.com/consult',
    timeoutMs: 90_000, // above the worst-case OpenClaw turn
  },
});

await phone.serve(agent);

import { defineTool } from 'getpatter';

const reschedule = defineTool({
  name: 'reschedule_appointment',
  description: 'Move an existing appointment to a new slot via the back-office API.',
  parameters: {
    type: 'object',
    properties: { apptId: { type: 'string' }, newSlot: { type: 'string' } },
    required: ['apptId', 'newSlot'],
  },
  // Raise above the 10 s default so a 30–60 s job isn't aborted mid-flight.
  timeoutMs: 60_000,
  // The caller hears this if the tool hasn't returned within the grace window.
  reassurance: 'Let me move that for you — one moment.',
  handler: async (args) => {
    /* call the back-office API; may take 30–60 s */
    return JSON.stringify({ status: 'rescheduled' });
  },
});

import * as openai from 'getpatter/engines/openai';

const engine = new openai.Realtime({
  // Suppress room noise / clicks / phone shifts the VAD would treat as speech.
  noiseReduction: 'far_field', // 'near_field' for a close-mic handset
  turnDetection: {
    type: 'server_vad',
    threshold: 0.7,            // raise from 0.5 so transients don't trip speech-start
    prefixPaddingMs: 300,
    silenceDurationMs: 700,    // let a contractor pause mid-thought without being cut
  },
});

Caller (any number, no allowlist)
  │
  ▼
Twilio DID  ──  Patter verifies X-Twilio-Signature at the public boundary
  │
  ▼
PATTER VOICE AGENT  (OpenAI Realtime: low-latency English, all-in-one, strong tool flow)
  · far_field noise reduction + tuned server_vad (threshold ~0.7, silence ~700 ms)
  · barge_in_threshold raised so a mouse-move never cuts the agent off
  · Patter owns turn-taking + TTS locally — the brain is NEVER on the per-turn path
  │
  │  turn needs real data/action →  speak "let me check, one moment" (reassurance)
  │                                  keep the media stream alive while the consult runs
  ▼
consult  →  local FastAPI adapter (loopback)  →  POST /v1/chat/completions
            model = "openclaw/receptionist-roofing-ca"   ← ONE scoped agent, never default
            user  = call_id                               ← one OpenClaw session per call
            X-Patter-Caller = caller                      ← caller-ID prefetch
  │
  ▼
OpenClaw RECEPTIONIST AGENT  (top-level agents.list[] entry, own auth, sandboxed)
  · tools.allow = D-Tools Cloud calendar + customer-DB only
  · tools.deny  = exec / write / browser / gateway
  · offloads slow work (reschedule, browser automation) to scoped sub-agents
  │
  ▼
Adapter returns a trimmed, spoken-ready reply  →  Patter SPEAKS the answer