@getdial/cli 0.42.0 → 0.44.0

package/dist/cli.js

@@ -18,6 +18,7 @@ import { runNumberPurchase } from "./commands/number/purchase.js";
 import { runNumberSet } from "./commands/number/set.js";
 import { runNumberWhatsapp } from "./commands/number/whatsapp.js";
 import { runGroupList } from "./commands/group/list.js";
+import { runLookup } from "./commands/lookup/lookup.js";
 import { runContactsList } from "./commands/contacts/list.js";
 import { runMessageSend } from "./commands/message/send.js";
 import { runMessageReply } from "./commands/message/reply.js";
@@ -337,6 +338,13 @@ program
     startingAfter: opts.startingAfter,
     json: !!opts.json,
 })));
+program
+    .command("lookup")
+    .argument("<number>", "the phone number to look up, in E.164 (e.g. +14155550123)")
+    .description("What channels a phone number can receive on, so you can pick one before sending. Works on " +
+    "any number, not just yours. GET /api/v1/lookup.")
+    .option("--json", "machine-readable output")
+    .action(async (number, opts) => process.exit(await runLookup(number, { json: !!opts.json })));
 const group = program
     .command("group")
     .description("Group conversations your lines are in (WhatsApp).");

package/dist/commands/call/get.js

@@ -1,6 +1,48 @@
 import { getCall } from "../../lib/ops/calls.js";
 import { isDialError } from "../../lib/ops/errors.js";
 import { printDialError } from "../../lib/cli-error.js";
+/**
+ * A silence long enough to call out. Three seconds is past a natural beat between
+ * speakers but short enough to catch an agent thinking too long, which is what
+ * anyone reading a transcript for pacing is looking for.
+ */
+const NOTABLE_PAUSE_MS = 3000;
+/**
+ * Plain words for who spoke. "person" rather than "caller" because on an outbound
+ * call the human is the callee; "transferred" for the third party a call was
+ * handed off to, who is a different human from the one who was on the line first.
+ */
+function speakerLabel(speaker) {
+    if (speaker === "agent")
+        return "agent";
+    return speaker === "transfer_target" ? "transferred" : "person";
+}
+/** ms into the call's audio → "m:ss.t", the stamp each transcript line carries. */
+function formatOffset(ms) {
+    const minutes = Math.floor(ms / 60000);
+    const seconds = Math.floor((ms % 60000) / 1000);
+    const tenths = Math.floor((ms % 1000) / 100);
+    return `${minutes}:${String(seconds).padStart(2, "0")}.${tenths}`;
+}
+/**
+ * Print the transcript with each turn stamped, and call out the long silences
+ * between them. The flat string cannot show a pause, which is the whole reason
+ * the timed turns exist.
+ */
+function printTimedTranscript(turns) {
+    console.log(`transcript:`);
+    turns.forEach((turn, i) => {
+        const previous = turns[i - 1];
+        if (previous) {
+            const pauseMs = turn.startMs - previous.endMs;
+            if (pauseMs >= NOTABLE_PAUSE_MS) {
+                console.log(`            ... ${(pauseMs / 1000).toFixed(1)}s pause`);
+            }
+        }
+        const speaker = speakerLabel(turn.speaker).padEnd(12);
+        console.log(`  ${formatOffset(turn.startMs).padStart(7)}  ${speaker}${turn.text}`);
+    });
+}
 export async function runCallGet(opts) {
     try {
         const c = await getCall(opts.callId);
@@ -19,7 +61,10 @@ export async function runCallGet(opts) {
             console.log(`instruction:`);
             console.log(c.instruction);
         }
-        if (c.transcript) {
+        if (c.transcriptTurns?.length) {
+            printTimedTranscript(c.transcriptTurns);
+        }
+        else if (c.transcript) {
             console.log(`transcript:`);
             console.log(c.transcript);
         }

package/dist/commands/lookup/lookup.js

@@ -0,0 +1,31 @@
+import { lookupNumber } from "../../lib/ops/lookup.js";
+import { isDialError } from "../../lib/ops/errors.js";
+import { printDialError } from "../../lib/cli-error.js";
+/** Channels in the order they are printed, with the label each one shows as. */
+const CHANNEL_LABELS = {
+    imessage: "iMessage",
+};
+export async function runLookup(number, opts) {
+    try {
+        const result = await lookupNumber(number);
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: true, ...result }));
+            return 0;
+        }
+        console.log(result.number);
+        for (const [channel, supported] of Object.entries(result.supports)) {
+            // A channel added to the API after this CLI shipped still prints, under its
+            // raw key — reporting an unknown channel is better than hiding it.
+            const label = CHANNEL_LABELS[channel] ?? channel;
+            console.log(`  ${label.padEnd(9)} ${supported ? "yes" : "no"}`);
+        }
+        return 0;
+    }
+    catch (e) {
+        // A lookup that could not be completed exits non-zero rather than printing
+        // "no": the two mean different things, and only one is worth retrying.
+        if (isDialError(e))
+            return printDialError(opts.json, e);
+        throw e;
+    }
+}

package/dist/lib/ops/lookup.js

@@ -0,0 +1,20 @@
+import { apiGet } from "../api.js";
+import { maybeAuth } from "./auth.js";
+import { DialError } from "./errors.js";
+/**
+ * Look a number up.
+ *
+ * Shared by `dial lookup` and the local MCP `lookup_number` tool, so both speak to
+ * the API through one place and inherit the saved key the same way.
+ *
+ * A lookup Dial could not complete comes back as an error (502), never as a
+ * negative verdict — so a `false` here always means the number genuinely is not
+ * reachable on that channel, and callers can treat the two differently.
+ */
+export async function lookupNumber(number) {
+    const auth = maybeAuth();
+    const res = await apiGet(`/api/v1/lookup?number=${encodeURIComponent(number)}`, auth?.apiKey);
+    if (!res.ok)
+        throw new DialError("lookup_failed", res.error, res.status);
+    return res.data;
+}

package/dist/mcp/schemas.js

@@ -147,6 +147,17 @@ export const messageSchema = z
     createdAt: z.string().optional(),
 })
     .passthrough();
+export const transcriptTurnSchema = z
+    .object({
+    speaker: z
+        .enum(["agent", "user", "transfer_target"])
+        .describe("`agent` is Dial's AI voice agent, `user` the human on the other end, and " +
+        "`transfer_target` the human the call was cold-transferred to"),
+    text: z.string().describe("What was said during the turn"),
+    startMs: z.number().describe("Approximate ms into the call's audio at which the turn began"),
+    endMs: z.number().describe("Approximate ms into the call's audio at which the turn ended"),
+})
+    .describe("One uninterrupted stretch of speech by one party, placed in time");
 export const callSchema = z
     .object({
     id: z.string(),
@@ -156,6 +167,13 @@ export const callSchema = z
     status: statusSchema,
     duration: z.number().nullish(),
     transcript: z.string().nullish(),
+    transcriptTurns: transcriptTurnSchema
+        .array()
+        .nullish()
+        .describe("The same conversation as `transcript`, split into timed turns and ordered by " +
+        "startMs. Use it to measure pacing: the pause before a turn is its startMs minus " +
+        "the previous turn's endMs. Null when the call has no transcript, or when the " +
+        "call's turn timing was not recorded."),
     instruction: z.string().nullable().optional(),
     createdAt: z.string().optional(),
 })

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

@@ -9,7 +9,9 @@ export const getCallTool = {
     name: "get_call",
     config: {
         title: "Get Call",
-        description: "Fetch a single call by id — status, duration, and transcript when available.",
+        description: "Fetch a single call by id — status, duration, and transcript when available. " +
+            "The transcript comes back twice: `transcript` as flat text, and `transcriptTurns` " +
+            "as timed turns for analysing pacing and spotting long pauses.",
         inputSchema,
         outputSchema: { call: callSchema },
         annotations: { readOnlyHint: true, openWorldHint: true },

package/dist/mcp/tools/index.js

@@ -8,6 +8,7 @@ import { stopTypingTool } from "./stop-typing.js";
 import { listMessagesTool } from "./list-messages.js";
 import { listGroupsTool } from "./list-groups.js";
 import { listContactsTool } from "./list-contacts.js";
+import { lookupNumberTool } from "./lookup-number.js";
 import { placeCallTool } from "./place-call.js";
 import { listCallsTool } from "./list-calls.js";
 import { getCallTool } from "./get-call.js";
@@ -35,6 +36,7 @@ export const tools = [
     listMessagesTool,
     listGroupsTool,
     listContactsTool,
+    lookupNumberTool,
     placeCallTool,
     listCallsTool,
     getCallTool,

package/dist/mcp/tools/lookup-number.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { lookupNumber } from "../../lib/ops/lookup.js";
+const inputSchema = {
+    number: z
+        .string()
+        .describe("The phone number to look up, in E.164 — e.g. +14155550123. Any number, not just your own."),
+};
+export const lookupNumberTool = {
+    name: "lookup_number",
+    config: {
+        title: "Look Up A Number",
+        description: "Check what channels a phone number can receive on, before sending to it. Works on ANY number in the " +
+            "world — it doesn't have to be one of your numbers, and you don't have to have messaged it before. " +
+            "`supports` describes the number you asked about, not your own line: each key is a channel and the " +
+            "boolean says whether that number can be reached there. Read the channels you need by name, since more " +
+            "are added over time. The answer is point-in-time, not a property of the number — someone who changes " +
+            "device or turns the service off stops being reachable — so treat `true` as a strong signal for picking " +
+            "a channel rather than a promise that the send will land. A lookup that fails is an error, never a " +
+            "`false`, so a `false` always means the number genuinely isn't reachable there.",
+        inputSchema,
+        outputSchema: {
+            number: z.string().describe("The number you asked about, normalized to E.164"),
+            supports: z
+                .object({
+                imessage: z.boolean().describe("Whether the number can currently receive iMessage"),
+            })
+                .describe("One key per channel, true when the number can be reached there"),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    },
+    run: async (args) => jsonResult(await lookupNumber(args.number)),
+};

package/dist/mcp/tools/tool-names.js

@@ -31,6 +31,7 @@ export const OPERATIONAL_TOOL_NAMES = [
     "list_messages",
     "list_groups",
     "list_contacts",
+    "lookup_number",
     "place_call",
     "list_calls",
     "get_call",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getdial/cli",
-  "version": "0.42.0",
+  "version": "0.44.0",
   "description": "Dial CLI — install, sign up, and run the local listen service.",
   "license": "MIT",
   "repository": {