@getdial/cli 0.13.1 → 0.14.0

package/dist/lib/ops/events.js

@@ -0,0 +1,63 @@
+import { paths } from "../paths.js";
+import { supervisorStatus } from "../supervisor/index.js";
+import { parseFieldArg, parseRegexArg } from "../event-filter.js";
+import { currentSize, findLatestMatch, tailUntilMatch } from "../log-tail.js";
+import { apiPost } from "../api.js";
+import { requireAuth } from "./auth.js";
+import { DialError } from "./errors.js";
+const PER_POLL_SECONDS = 30;
+/**
+ * Wait for a matching account event. Tails the local listen log when the daemon is
+ * running, otherwise long-polls the REST API. Console-free: returns what to print and
+ * whether it timed out; throws DialError for auth/API failures.
+ */
+export async function waitForEvent(opts) {
+    const spec = {
+        eventType: opts.eventType,
+        fields: opts.fields.map(parseFieldArg),
+        regexes: opts.regexes.map(parseRegexArg),
+    };
+    const status = supervisorStatus();
+    if (status.installed && status.running)
+        return waitFromLog(spec, opts);
+    return waitFromApi(spec, opts);
+}
+async function waitFromLog(spec, opts) {
+    const file = paths().listenLog;
+    const startOffset = currentSize(file);
+    const hit = await tailUntilMatch(file, spec, startOffset, opts.timeoutSeconds * 1000);
+    if (hit)
+        return { source: "log", timedOut: false, event: hit.obj, line: hit.line };
+    const fallback = findLatestMatch(file, spec);
+    if (fallback)
+        return { source: "log", timedOut: true, event: fallback.obj, line: fallback.line };
+    return { source: null, timedOut: true, event: null, line: null };
+}
+async function waitFromApi(spec, opts) {
+    const auth = requireAuth();
+    const filters = {};
+    for (const f of spec.fields)
+        filters[f.name] = f.value;
+    const regexFilters = {};
+    for (const r of spec.regexes)
+        regexFilters[r.name] = { pattern: r.regex.source, flags: r.regex.flags };
+    const deadline = Date.now() + opts.timeoutSeconds * 1000;
+    while (Date.now() < deadline) {
+        const remainingSec = Math.max(1, Math.ceil((deadline - Date.now()) / 1000));
+        const timeout = Math.min(PER_POLL_SECONDS, remainingSec);
+        const res = await apiPost("/api/v1/events/wait", {
+            eventType: spec.eventType,
+            filters: Object.keys(filters).length > 0 ? filters : undefined,
+            regexFilters: Object.keys(regexFilters).length > 0 ? regexFilters : undefined,
+            timeout,
+        }, auth.apiKey);
+        if (res.ok && res.data?.event) {
+            return { source: "api", timedOut: false, event: res.data.event, line: JSON.stringify(res.data.event) };
+        }
+        if (res.ok === false && res.status === 408)
+            continue;
+        if (res.ok === false)
+            throw new DialError("api_fallback_failed", res.error, res.status);
+    }
+    return { source: "api", timedOut: true, event: null, line: null };
+}

package/dist/lib/ops/listen.js

@@ -0,0 +1,51 @@
+import { readFileSync } from "node:fs";
+import { installSupervised, uninstallSupervised, supervisorStatus, supervisorAvailability, lastEventAtFromLog, } from "../supervisor/index.js";
+import { paths } from "../paths.js";
+import { requireAuth } from "./auth.js";
+import { DialError } from "./errors.js";
+function resolveDialPath() {
+    return process.env.DIAL_BIN_OVERRIDE ?? process.argv[1] ?? "dial";
+}
+export function listenInstall() {
+    requireAuth();
+    const supervisor = supervisorAvailability();
+    if (!supervisor.available) {
+        throw new DialError("supervisor_unavailable", supervisor.reason);
+    }
+    try {
+        return installSupervised(resolveDialPath());
+    }
+    catch (err) {
+        throw new DialError("install_failed", err instanceof Error ? err.message : String(err));
+    }
+}
+export function listenUninstall() {
+    try {
+        uninstallSupervised();
+        return { ok: true };
+    }
+    catch (err) {
+        throw new DialError("uninstall_failed", err instanceof Error ? err.message : String(err));
+    }
+}
+export function listenStatus() {
+    const s = supervisorStatus();
+    const lastEventAt = lastEventAtFromLog(paths().listenLog);
+    let lastEvents = [];
+    try {
+        const raw = readFileSync(paths().listenLog, "utf8");
+        const lines = raw.trim().split("\n").filter(Boolean);
+        lastEvents = lines.slice(-5).map((l) => {
+            try {
+                return JSON.parse(l);
+            }
+            catch {
+                return l;
+            }
+        });
+    }
+    catch {
+        // no log yet — leave empty
+    }
+    return { installed: s.installed, running: s.running, pid: s.pid, unitPath: s.unitPath, lastEventAt, lastEvents };
+}

package/dist/lib/ops/local-targets.js

@@ -0,0 +1,35 @@
+import { addTarget, removeTarget, listTargets, targetId, LocalTargetError, DEFAULT_SIGNATURE_HEADER, } from "../local-targets.js";
+import { DialError } from "./errors.js";
+function wrap(fn) {
+    try {
+        return fn();
+    }
+    catch (err) {
+        if (err instanceof LocalTargetError)
+            throw new DialError(err.code, err.message);
+        throw err;
+    }
+}
+export function addUrlTarget(opts) {
+    const { added } = wrap(() => addTarget({
+        kind: "url",
+        url: opts.url,
+        secret: opts.secret,
+        signatureHeader: opts.signatureHeader ?? (opts.secret ? DEFAULT_SIGNATURE_HEADER : undefined),
+        bearer: opts.bearer,
+        timeoutSeconds: opts.timeoutSeconds,
+    }));
+    return { added, url: opts.url };
+}
+export function addCommandTarget(opts) {
+    const args = opts.args ?? [];
+    const { added } = wrap(() => addTarget({ kind: "cmd", path: opts.path, args, timeoutSeconds: opts.timeoutSeconds }));
+    return { added, path: opts.path, args };
+}
+export function removeLocalTarget(id) {
+    const { removed } = removeTarget(id);
+    return { removed, id };
+}
+export function listLocalTargets() {
+    return listTargets().map((t) => ({ kind: t.kind, id: targetId(t), target: t }));
+}

package/dist/lib/ops/messages.js

@@ -0,0 +1,26 @@
+import { apiGet, apiPost } from "../api.js";
+import { requireAuth, requireFromNumberId } from "./auth.js";
+import { DialError } from "./errors.js";
+export async function sendMessage(opts) {
+    const auth = requireAuth();
+    const fromNumberId = requireFromNumberId(auth, opts.fromNumberId);
+    const res = await apiPost("/api/v1/messages", { to: opts.to, body: opts.body, channel: "sms", fromNumberId }, auth.apiKey);
+    if (!res.ok)
+        throw new DialError("send_failed", res.error, res.status);
+    return res.data.message;
+}
+export async function listMessages(opts) {
+    const auth = requireAuth();
+    const params = new URLSearchParams();
+    if (opts.numberId)
+        params.set("numberId", opts.numberId);
+    if (opts.direction)
+        params.set("direction", opts.direction);
+    if (opts.since)
+        params.set("since", opts.since);
+    const qs = params.toString();
+    const res = await apiGet(qs ? `/api/v1/messages?${qs}` : "/api/v1/messages", auth.apiKey);
+    if (!res.ok)
+        throw new DialError("list_failed", res.error, res.status);
+    return res.data.messages ?? [];
+}

package/dist/lib/ops/numbers.js

@@ -0,0 +1,39 @@
+import { apiGet, apiPost, apiPatch } from "../api.js";
+import { requireAuth } from "./auth.js";
+import { DialError } from "./errors.js";
+export async function listNumbers() {
+    const auth = requireAuth();
+    const res = await apiGet("/api/v1/numbers", auth.apiKey);
+    if (!res.ok)
+        throw new DialError("list_failed", res.error, res.status);
+    return { numbers: res.data.numbers ?? [], defaultNumberId: auth.phoneNumberId ?? null };
+}
+export async function purchaseNumber(opts) {
+    const auth = requireAuth();
+    const body = { inboundInstruction: opts.inboundInstruction };
+    if (opts.country)
+        body.country = opts.country;
+    if (opts.areaCode)
+        body.areaCode = opts.areaCode;
+    const res = await apiPost("/api/v1/numbers", body, auth.apiKey);
+    if (!res.ok)
+        throw new DialError("purchase_failed", res.error, res.status);
+    return res.data.number;
+}
+export async function setNumberProperties(opts) {
+    const auth = requireAuth();
+    // The REST API keys numbers by id; the CLI/tool takes the E.164 number for ergonomics,
+    // so resolve it to its id first.
+    const list = await apiGet("/api/v1/numbers", auth.apiKey);
+    if (!list.ok)
+        throw new DialError("list_failed", list.error, list.status);
+    const match = list.data.numbers.find((n) => n.number === opts.number);
+    if (!match) {
+        const known = list.data.numbers.map((n) => n.number).join(", ") || "(none)";
+        throw new DialError("number_not_found", `No phone number ${opts.number} on your account. Yours: ${known}.`);
+    }
+    const res = await apiPatch(`/api/v1/numbers/${match.id}`, { inboundInstruction: opts.inboundInstruction }, auth.apiKey);
+    if (!res.ok)
+        throw new DialError("update_failed", res.error, res.status);
+    return res.data.number;
+}

package/dist/lib/supervisor/systemd.js

@@ -8,20 +8,6 @@ function isSystemctlNotLoaded(err) {
     const text = stderr ? stderr.toString() : "";
     return /not loaded|does not exist|Unit .* not found/i.test(text);
 }
-/**
- * True when the error means systemd simply isn't usable here — no systemctl on
- * PATH, or no user session bus (sandbox / container / CI / non-systemd distro).
- * These are expected on many machines, so they should be logged at debug, not
- * dumped as a scary warning with a full stack trace.
- */
-function isSystemdUnavailable(err) {
-    const e = err;
-    if (e.code === "ENOENT")
-        return true; // systemctl / loginctl not installed
-    const stderr = e.stderr ? e.stderr.toString() : "";
-    const text = stderr || e.message || "";
-    return /Failed to connect to bus|No medium found|XDG_RUNTIME_DIR|not been booted with systemd|Connection refused|Permission denied/i.test(text);
-}
 function isEnoent(err) {
     return err.code === "ENOENT";
 }
@@ -88,11 +74,11 @@ export function systemctlStatus() {
         return { running: active, pid: active && pid > 0 ? pid : null };
     }
     catch (err) {
-        // Expected on machines without a systemd user session — stay quiet there.
-        if (isSystemdUnavailable(err))
-            logger.debug({ err }, "systemd not available; treating listen service as not running");
-        else
-            logger.warn({ err }, "systemctl show failed");
+        // Best-effort status probe. Any failure — systemctl missing, no user session
+        // bus (sandbox/container/CI), unit unknown — just means "not running" for our
+        // purposes. Log at debug so we never dump a stack trace to a user's stderr;
+        // run with DIAL_LOG_LEVEL=debug to see it.
+        logger.debug({ err }, "systemctl show failed; treating listen service as not running");
         return { running: false, pid: null };
     }
 }
@@ -102,10 +88,8 @@ export function lingerEnabled(user) {
         return /Linger=yes/.test(out);
     }
     catch (err) {
-        if (isSystemdUnavailable(err))
-            logger.debug({ err, user }, "loginctl unavailable; assuming linger disabled");
-        else
-            logger.warn({ err, user }, "loginctl show-user failed; assuming linger disabled");
+        // Best-effort; debug only (see systemctlStatus). Assume linger disabled.
+        logger.debug({ err, user }, "loginctl show-user failed; assuming linger disabled");
         return false;
     }
 }

package/dist/mcp/register.js

@@ -0,0 +1,27 @@
+import { ZodError } from "zod";
+import { tools } from "./tools/index.js";
+import { errorResult } from "./result.js";
+import { isDialError } from "../lib/ops/errors.js";
+import { logger } from "../lib/log.js";
+/**
+ * Register every tool onto the MCP server. DialError/ZodError surface their message to
+ * the model as a tool error; unexpected errors are logged (to stderr — safe for stdio)
+ * and surfaced generically.
+ */
+export function registerTools(server) {
+    for (const tool of tools) {
+        server.registerTool(tool.name, tool.config, async (args) => {
+            try {
+                return await tool.run(args ?? {});
+            }
+            catch (err) {
+                if (isDialError(err))
+                    return errorResult(err.message);
+                if (err instanceof ZodError)
+                    return errorResult(`Invalid input: ${err.message}`);
+                logger.error({ err, tool: tool.name }, "mcp tool error");
+                return errorResult("Internal error running tool.");
+            }
+        });
+    }
+}

package/dist/mcp/result.js

@@ -0,0 +1,6 @@
+export function jsonResult(data) {
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+export function errorResult(message) {
+    return { content: [{ type: "text", text: message }], isError: true };
+}

package/dist/mcp/server.js

@@ -0,0 +1,20 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { VERSION } from "../lib/version.js";
+import { registerTools } from "./register.js";
+// Server identity shown by MCP clients. Mirrors the remote Dial MCP server: name/title +
+// the scalable Dial favicon (served same-origin, https). SVG with sizes:["any"] covers
+// every render size.
+const SERVER_INFO = {
+    name: "dial",
+    title: "Dial",
+    version: VERSION,
+    websiteUrl: "https://getdial.ai",
+    icons: [
+        { src: "https://getdial.ai/favicon.svg", mimeType: "image/svg+xml", sizes: ["any"] },
+    ],
+};
+export function buildServer() {
+    const server = new McpServer(SERVER_INFO);
+    registerTools(server);
+    return server;
+}

package/dist/mcp/tool.js

@@ -0,0 +1 @@
+export {};

package/dist/mcp/tools/add-command-target.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { addCommandTarget } from "../../lib/ops/local-targets.js";
+const inputSchema = {
+    path: z.string().min(1).describe("Absolute path to an executable the daemon spawns once per event"),
+    args: z.array(z.string()).optional().describe("Extra args; the event JSON is appended as the final positional arg"),
+    timeoutSeconds: z.number().int().positive().optional().describe("Per-attempt timeout (default 5)"),
+};
+export const addCommandTargetTool = {
+    name: "add_command_target",
+    config: {
+        title: "Add Command Fan-out Target",
+        description: "Register an executable the local listen daemon runs once per event (event JSON as the final arg).",
+        inputSchema,
+        annotations: {},
+    },
+    run: async (args) => jsonResult(addCommandTarget({
+        path: args.path,
+        args: args.args,
+        timeoutSeconds: args.timeoutSeconds,
+    })),
+};

package/dist/mcp/tools/add-url-target.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { addUrlTarget } from "../../lib/ops/local-targets.js";
+const inputSchema = {
+    url: z.string().min(1).describe("Loopback HTTP endpoint the listen daemon POSTs each event JSON to"),
+    secret: z.string().optional().describe("HMAC-SHA256 key; the daemon signs each request body and sends the hex digest"),
+    signatureHeader: z.string().optional().describe("Header for the HMAC signature (default X-Dial-Signature; only with secret)"),
+    bearer: z.string().optional().describe("Static bearer token, sent as Authorization: Bearer <token>"),
+    timeoutSeconds: z.number().int().positive().optional().describe("Per-attempt timeout (default 5)"),
+};
+export const addUrlTargetTool = {
+    name: "add_url_target",
+    config: {
+        title: "Add URL Fan-out Target",
+        description: "Register a loopback HTTP endpoint the local listen daemon delivers each event to.",
+        inputSchema,
+        annotations: {},
+    },
+    run: async (args) => jsonResult(addUrlTarget({
+        url: args.url,
+        secret: args.secret,
+        signatureHeader: args.signatureHeader,
+        bearer: args.bearer,
+        timeoutSeconds: args.timeoutSeconds,
+    })),
+};

package/dist/mcp/tools/get-account-status.js

@@ -0,0 +1,13 @@
+import { jsonResult } from "../result.js";
+import { accountStatus } from "../../lib/ops/account.js";
+export const getAccountStatusTool = {
+    name: "get_account_status",
+    config: {
+        title: "Get Account Status",
+        description: "Report local Dial setup state: CLI version, backend reachability, sign-in/key validity, " +
+            "any pending OTP, the listen daemon state, and the recommended next step.",
+        inputSchema: {},
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    },
+    run: async () => jsonResult(await accountStatus()),
+};

package/dist/mcp/tools/get-call.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { getCall } from "../../lib/ops/calls.js";
+const inputSchema = {
+    callId: z.string().min(1).describe("The call id to fetch"),
+};
+export const getCallTool = {
+    name: "get_call",
+    config: {
+        title: "Get Call",
+        description: "Fetch a single call by id — status, duration, and transcript when available.",
+        inputSchema,
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    },
+    run: async (args) => jsonResult(await getCall(args.callId)),
+};

package/dist/mcp/tools/index.js

@@ -0,0 +1,41 @@
+import { listNumbersTool } from "./list-numbers.js";
+import { purchaseNumberTool } from "./purchase-number.js";
+import { setNumberPropertiesTool } from "./set-number-properties.js";
+import { sendMessageTool } from "./send-message.js";
+import { listMessagesTool } from "./list-messages.js";
+import { placeCallTool } from "./place-call.js";
+import { listCallsTool } from "./list-calls.js";
+import { getCallTool } from "./get-call.js";
+import { getAccountStatusTool } from "./get-account-status.js";
+import { signUpTool } from "./sign-up.js";
+import { onboardTool } from "./onboard.js";
+import { waitForEventTool } from "./wait-for-event.js";
+import { addUrlTargetTool } from "./add-url-target.js";
+import { addCommandTargetTool } from "./add-command-target.js";
+import { removeLocalTargetTool } from "./remove-local-target.js";
+import { listLocalTargetsTool } from "./list-local-targets.js";
+import { listenInstallTool } from "./listen-install.js";
+import { listenUninstallTool } from "./listen-uninstall.js";
+import { listenStatusTool } from "./listen-status.js";
+/** Every tool registered on the local stdio MCP server. */
+export const tools = [
+    listNumbersTool,
+    purchaseNumberTool,
+    setNumberPropertiesTool,
+    sendMessageTool,
+    listMessagesTool,
+    placeCallTool,
+    listCallsTool,
+    getCallTool,
+    getAccountStatusTool,
+    signUpTool,
+    onboardTool,
+    waitForEventTool,
+    addUrlTargetTool,
+    addCommandTargetTool,
+    removeLocalTargetTool,
+    listLocalTargetsTool,
+    listenInstallTool,
+    listenUninstallTool,
+    listenStatusTool,
+];

package/dist/mcp/tools/list-calls.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { listCalls } from "../../lib/ops/calls.js";
+const inputSchema = {
+    numberId: z.string().optional().describe("Filter to a single phone number id"),
+    direction: z.enum(["inbound", "outbound"]).optional().describe("Filter by direction"),
+    since: z.string().optional().describe("Only calls created after this ISO-8601 timestamp"),
+};
+export const listCallsTool = {
+    name: "list_calls",
+    config: {
+        title: "List Calls",
+        description: "List recent calls on your account, newest first.",
+        inputSchema,
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    },
+    run: async (args) => jsonResult(await listCalls({
+        numberId: args.numberId,
+        direction: args.direction,
+        since: args.since,
+    })),
+};

package/dist/mcp/tools/list-local-targets.js

@@ -0,0 +1,12 @@
+import { jsonResult } from "../result.js";
+import { listLocalTargets } from "../../lib/ops/local-targets.js";
+export const listLocalTargetsTool = {
+    name: "list_local_targets",
+    config: {
+        title: "List Fan-out Targets",
+        description: "List the local fan-out targets the listen daemon currently delivers events to.",
+        inputSchema: {},
+        annotations: { readOnlyHint: true },
+    },
+    run: async () => jsonResult(listLocalTargets()),
+};

package/dist/mcp/tools/list-messages.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { listMessages } from "../../lib/ops/messages.js";
+const inputSchema = {
+    numberId: z.string().optional().describe("Filter to a single phone number id"),
+    direction: z.enum(["inbound", "outbound"]).optional().describe("Filter by direction"),
+    since: z.string().optional().describe("Only messages created after this ISO-8601 timestamp"),
+};
+export const listMessagesTool = {
+    name: "list_messages",
+    config: {
+        title: "List Messages",
+        description: "List recent messages on your account, newest first.",
+        inputSchema,
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    },
+    run: async (args) => jsonResult(await listMessages({
+        numberId: args.numberId,
+        direction: args.direction,
+        since: args.since,
+    })),
+};

package/dist/mcp/tools/list-numbers.js

@@ -0,0 +1,12 @@
+import { jsonResult } from "../result.js";
+import { listNumbers } from "../../lib/ops/numbers.js";
+export const listNumbersTool = {
+    name: "list_numbers",
+    config: {
+        title: "List Phone Numbers",
+        description: "List the phone numbers on your Dial account, with the default number id.",
+        inputSchema: {},
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    },
+    run: async () => jsonResult(await listNumbers()),
+};

package/dist/mcp/tools/listen-install.js

@@ -0,0 +1,13 @@
+import { jsonResult } from "../result.js";
+import { listenInstall } from "../../lib/ops/listen.js";
+export const listenInstallTool = {
+    name: "listen_install",
+    config: {
+        title: "Install Listen Daemon",
+        description: "Install the background event daemon (launchd on macOS, systemd --user on Linux) so inbound " +
+            "SMS and call-ended events are delivered to this machine in real time.",
+        inputSchema: {},
+        annotations: {},
+    },
+    run: async () => jsonResult(listenInstall()),
+};

package/dist/mcp/tools/listen-status.js

@@ -0,0 +1,12 @@
+import { jsonResult } from "../result.js";
+import { listenStatus } from "../../lib/ops/listen.js";
+export const listenStatusTool = {
+    name: "listen_status",
+    config: {
+        title: "Listen Daemon Status",
+        description: "Report the background event daemon's state (installed/running/pid) and the last few events.",
+        inputSchema: {},
+        annotations: { readOnlyHint: true },
+    },
+    run: async () => jsonResult(listenStatus()),
+};

package/dist/mcp/tools/listen-uninstall.js

@@ -0,0 +1,12 @@
+import { jsonResult } from "../result.js";
+import { listenUninstall } from "../../lib/ops/listen.js";
+export const listenUninstallTool = {
+    name: "listen_uninstall",
+    config: {
+        title: "Uninstall Listen Daemon",
+        description: "Stop and remove the background event daemon from this machine.",
+        inputSchema: {},
+        annotations: { destructiveHint: true },
+    },
+    run: async () => jsonResult(listenUninstall()),
+};

package/dist/mcp/tools/onboard.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { onboard } from "../../lib/ops/account.js";
+const inputSchema = {
+    code: z.string().min(1).describe("6-digit OTP from the sign-up email"),
+    verificationId: z.string().optional().describe("Explicit verification id (defaults to the local pending signup)"),
+    inboundInstruction: z.string().optional().describe("System prompt for inbound calls to a newly provisioned number (new accounts)"),
+    agents: z.array(z.string()).optional().describe("Agent names to install the Dial skill into (e.g. claude-code, cursor)"),
+};
+export const onboardTool = {
+    name: "onboard",
+    config: {
+        title: "Onboard",
+        description: "Verify the sign-up OTP and finish onboarding: saves the API key locally and optionally installs " +
+            "the Dial skill into named agents. Returns the account summary (the raw API key is never returned).",
+        inputSchema,
+        annotations: { openWorldHint: true },
+    },
+    run: async (args) => {
+        const r = await onboard({
+            code: args.code,
+            verificationId: args.verificationId,
+            inboundInstruction: args.inboundInstruction,
+            agents: args.agents,
+        });
+        // Never surface the raw API key to the model; it's saved to disk for the CLI to read.
+        const { apiKey: _omit, ...safe } = r;
+        void _omit;
+        return jsonResult({
+            ...safe,
+            listenAvailable: r.supervisor.available,
+        });
+    },
+};

package/dist/mcp/tools/place-call.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { placeCall } from "../../lib/ops/calls.js";
+const inputSchema = {
+    to: z.string().min(7).describe("Destination phone number, E.164 (e.g. +14155550123)"),
+    outboundInstruction: z.string().min(1).describe("System prompt for the AI voice agent on this call"),
+    language: z.string().default("en-US").describe("BCP-47 language tag for the call"),
+    fromNumberId: z.string().optional().describe("Number id to call from; defaults to your primary number"),
+};
+export const placeCallTool = {
+    name: "place_call",
+    config: {
+        title: "Place AI Voice Call",
+        description: "Place an outbound voice call handled by an AI agent. The call runs asynchronously — " +
+            "use wait_for_event to block until it ends, then get_call for the transcript.",
+        inputSchema,
+        annotations: { openWorldHint: true },
+    },
+    run: async (args) => {
+        const call = await placeCall({
+            to: args.to,
+            outboundInstruction: args.outboundInstruction,
+            language: args.language ?? "en-US",
+            fromNumberId: args.fromNumberId,
+        });
+        return jsonResult({
+            call,
+            hint: `The call is now in progress. To be notified when it ends, call wait_for_event with ` +
+                `eventType "call.ended" and field "callId=${call.id}". Then call get_call with callId ` +
+                `"${call.id}" for the final status, duration, and transcript.`,
+        });
+    },
+};