callkaro-cli-unofficial 0.3.0 → 0.4.0

package/README.md

@@ -176,6 +176,10 @@ npm run catalog:check    # fail if catalog.json disagrees with the snapshot
 
 ### Smaller things
 
+- `cku agents chat` — text chat with an agent's real prompt and tools, no phone call. Scriptable with `--say`, replayable with `--history`. Custom in-call functions run for real
+- `cku scheduled list|queued|get` — scheduled calls and the queue of what will actually dial (dashboard login)
+- `cku sim update` — edit a test case in place
+- `cku calls list --postcall dnc_requested=true --provider-type plivo --sid <sid>` — filters the official CLI doesn't expose
 - `cku calls logs` — grep/awk/sed over the raw call log, in-process, no subprocess and no shell
 - `cku accounts status` — reports which account is in effect **and where that choice came from**
 - Per-project binding, so parallel agents can't redirect each other
@@ -219,7 +223,7 @@ Single test file:
 node --test tests/agentUpdate.test.js
 ```
 
-210 tests. No linter or formatter is configured.
+269 tests. No linter or formatter is configured.
 
 ### Layout
 

package/dist/commands/agentChat.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentChatCommand = agentChatCommand;
+const fs_1 = require("fs");
+const prompts_1 = __importDefault(require("prompts"));
+const chalk_1 = __importDefault(require("chalk"));
+const session_1 = require("../lib/session");
+const ui_1 = require("../lib/ui");
+const versions_1 = require("../lib/versions");
+const types_1 = require("../lib/types");
+const jsonInput_1 = require("./jsonInput");
+/**
+ * Text-only conversation with an agent over POST /cli/simulations/generate-reply.
+ * One request per user turn: the server replays the whole history through the
+ * agent's real prompt and tools and returns the next agent turn. No call, no
+ * telephony spend.
+ *
+ * Tools: the Python side mocks end_call, transfer_call, warm_transfer,
+ * keep_call_on_hold, change_conversation_language, send_booking_link_to_whatsapp,
+ * use_knowledge_base and collect_digits_via_dtmf. Every other function RUNS FOR
+ * REAL (and falls back to a mock if it throws) — a CRM write in an in-call
+ * function really happens.
+ */
+const MOCKED_TOOLS = new Set([
+    'end_call', 'transfer_call', 'warm_transfer', 'keep_call_on_hold',
+    'change_conversation_language', 'send_booking_link_to_whatsapp',
+    'use_knowledge_base', 'collect_digits_via_dtmf',
+]);
+/** Agent text of a message item; the server returns `content` as an array of strings. */
+const text = (item) => Array.isArray(item.content) ? item.content.join(' ') : String(item.content ?? '');
+const isEnd = (items) => items.some((i) => i.type === 'function_call' && i.name === 'end_call');
+/** Turn the server's error for a bad version or history into one that names the fix. */
+function explain(err, versionId) {
+    if (!(err instanceof types_1.ApiError))
+        return err;
+    if (err.status === 502 && /Invalid version id|Agent version not found/i.test(err.message)) {
+        return new Error(`Version ${versionId} is not a version of this agent. List them with: cku agents versions <agentId>`);
+    }
+    if (err.status === 400 && /must end with a user message/i.test(err.message)) {
+        return new Error('The chat history must end with a user turn. Add one with --say "<text>".');
+    }
+    return err;
+}
+function printItems(items, warned) {
+    for (const item of items) {
+        if (item.type === 'message' && item.role === 'assistant') {
+            (0, ui_1.info)(`${chalk_1.default.cyan('agent>')} ${text(item)}`);
+        }
+        else if (item.type === 'function_call') {
+            const result = JSON.stringify(item.extra?.result ?? null);
+            (0, ui_1.info)(chalk_1.default.dim(`  → ${item.name} ${item.arguments || '{}'} = ${result}`));
+            if (!MOCKED_TOOLS.has(item.name) && !warned.has(item.name)) {
+                warned.add(item.name);
+                console.error(chalk_1.default.yellow(`  ! ${item.name} is not mocked: it ran for real.`));
+            }
+        }
+    }
+}
+async function buildMetadata(opts) {
+    const metadata = {};
+    if (opts.metadata) {
+        const parsed = await (0, jsonInput_1.readJsonFlag)(opts.metadata, '--metadata');
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new Error('--metadata must be a JSON object, e.g. {"customer_name":"Ravi"}');
+        }
+        Object.assign(metadata, parsed);
+    }
+    for (const pair of opts.var || []) {
+        const idx = pair.indexOf('=');
+        if (idx < 1)
+            throw new Error(`Bad --var "${pair}". Use key=value, e.g. --var customer_name=Ravi`);
+        metadata[pair.slice(0, idx)] = pair.slice(idx + 1);
+    }
+    return metadata;
+}
+async function agentChatCommand(agentId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const versionId = (0, versions_1.firstVersion)(opts.versions);
+        const metadata = await buildMetadata(opts);
+        let history = [];
+        if (opts.history) {
+            const parsed = await (0, jsonInput_1.readJsonFlag)(opts.history, '--history');
+            if (!Array.isArray(parsed))
+                throw new Error('--history must be a JSON array of chat items (the output of --json).');
+            history = parsed;
+        }
+        const scripted = (opts.say?.length ?? 0) > 0 || Boolean(opts.history);
+        if (!scripted)
+            (0, ui_1.needTty)('Pass --say "<text>" (repeatable) or --history @file.json to run without a terminal.');
+        // Python requires userId in the body; take it from the token's own account.
+        const me = await api.me();
+        const userId = me.user?.id;
+        if (!userId)
+            throw new Error('Could not read your account id from /cli/auth/me.');
+        const warned = new Set();
+        let promptShown = false;
+        let ended = false;
+        const turn = async () => {
+            const res = await api
+                .generateReply({ userId, agent_id: agentId, chat_history: history, configuration: {}, epoch: 1, metadata }, versionId)
+                .catch((e) => { throw explain(e, versionId); });
+            if (opts.showPrompt && !promptShown) {
+                promptShown = true;
+                const sys = (res.messages || []).find((m) => m.role === 'system');
+                if (sys)
+                    (0, ui_1.info)(chalk_1.default.dim(`--- system prompt ---\n${sys.content}\n---------------------`));
+            }
+            const items = res.replies?.[0] || [];
+            history.push(...items);
+            if (!opts.json)
+                printItems(items, warned);
+            ended = isEnd(items);
+        };
+        const userSays = async (line) => {
+            history.push({ type: 'message', role: 'user', content: line });
+            if (!opts.json)
+                (0, ui_1.info)(`${chalk_1.default.green('you>')} ${line}`);
+            await turn();
+        };
+        // A replayed history may already end on a user turn waiting for its reply.
+        if (history.length && history[history.length - 1].role === 'user')
+            await turn();
+        if (scripted) {
+            for (const line of opts.say || []) {
+                if (ended)
+                    break;
+                await userSays(line);
+            }
+        }
+        else {
+            (0, ui_1.info)(chalk_1.default.dim('Text chat with the agent. /reset, /save <file>, /exit. Ends after end_call.'));
+            while (!ended) {
+                const { line } = await (0, prompts_1.default)({ type: 'text', name: 'line', message: 'you' });
+                if (line === undefined || line === '/exit')
+                    break;
+                const cmd = String(line).trim();
+                if (!cmd)
+                    continue;
+                if (cmd === '/reset') {
+                    history = [];
+                    (0, ui_1.info)(chalk_1.default.dim('History cleared.'));
+                    continue;
+                }
+                if (cmd.startsWith('/save ')) {
+                    (0, fs_1.writeFileSync)(cmd.slice(6).trim(), JSON.stringify(history, null, 2));
+                    (0, ui_1.info)(chalk_1.default.dim(`Saved ${history.length} items.`));
+                    continue;
+                }
+                await userSays(cmd);
+            }
+        }
+        if (ended && !opts.json)
+            (0, ui_1.info)(chalk_1.default.dim('(agent ended the call)'));
+        if (opts.save)
+            (0, fs_1.writeFileSync)(opts.save, JSON.stringify(history, null, 2));
+        if (opts.json)
+            console.log(JSON.stringify(history, null, 2));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}

package/dist/commands/calls.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.postcallQuery = postcallQuery;
 exports.buildCallQuery = buildCallQuery;
 exports.callsListCommand = callsListCommand;
 exports.callsGetCommand = callsGetCommand;
@@ -17,6 +18,24 @@ function fmtTime(v) {
     const d = new Date(v);
     return isNaN(d.getTime()) ? '' : d.toLocaleString('en-US');
 }
+/**
+ * `--postcall name=true|false` → `postcall_name=true|false`. The server only matches
+ * the literal strings `true`/`false` and silently drops any other value, which would
+ * return every call — so anything else is rejected here.
+ */
+function postcallQuery(pairs = []) {
+    const out = {};
+    for (const pair of pairs) {
+        const m = /^([^=\s]+)=(true|false)$/.exec(pair.trim());
+        if (!m) {
+            throw new Error(`Invalid --postcall "${pair}". Use --postcall <variable>=true or <variable>=false ` +
+                `(boolean post-call variables only; the server ignores any other value). ` +
+                `Example: --postcall dnc_requested=true`);
+        }
+        out[`postcall_${m[1]}`] = m[2];
+    }
+    return out;
+}
 function buildCallQuery(o) {
     return {
         name: o.type,
@@ -31,6 +50,9 @@ function buildCallQuery(o) {
         conversion_status: o.converted,
         lead_id: o.lead,
         buylead: o.buylead,
+        provider_type: o.providerType,
+        call_sid: o.sid,
+        ...postcallQuery(o.postcall),
     };
 }
 async function callsListCommand(opts) {

package/dist/commands/scheduled.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scheduledListCommand = scheduledListCommand;
+exports.scheduledQueuedCommand = scheduledQueuedCommand;
+exports.scheduledGetCommand = scheduledGetCommand;
+const dashboardApi_1 = require("../lib/dashboardApi");
+const ui_1 = require("../lib/ui");
+/**
+ * Scheduled calls, read-only. `/schedulecalls/v1/*` takes the dashboard cookie,
+ * so these need `cku dashboard login`; the `/cli` tree has no scheduled-call
+ * routes and the `/mcp` ones reject the ck_ token.
+ *
+ * No cancel: the backend's single-call delete removes the job and books a new
+ * attempt instead, and neither delete checks ownership of the job id.
+ */
+const when = (v) => {
+    if (v === undefined || v === null || v === '')
+        return '';
+    const d = new Date(v);
+    return isNaN(d.getTime()) ? String(v) : d.toLocaleString('en-US');
+};
+const agentName = (a) => (a && typeof a === 'object' ? a.name || a._id : a) || '';
+async function scheduledListCommand(opts) {
+    try {
+        const page = (0, ui_1.intFlag)(opts.page, '--page', 1);
+        const pageSize = (0, ui_1.intFlag)(opts.limit, '--limit', 50);
+        const res = await (0, dashboardApi_1.dashboardApi)().scheduledCalls({ page, pageSize });
+        const rows = res?.scheduleCalls || [];
+        if (opts.json)
+            return void console.log(JSON.stringify(rows, null, 2));
+        if (!rows.length)
+            return void (0, ui_1.info)('No scheduled calls.');
+        (0, ui_1.table)(['ID', 'TO', 'AGENT', 'SCHEDULED FOR', 'RETRIES', 'BATCH'], rows.map((r) => [r._id, r.to_number, agentName(r.agent_id), r.schedule_at, r.number_of_retries ?? '', r.batch_id || '']));
+        const p = res.pagination || {};
+        (0, ui_1.info)(`Page ${p.page ?? page} of ${p.totalPages ?? '?'} (${p.totalDocs ?? rows.length} total). Created today: ${res.todaysCalls ?? 0}.`);
+        if (p.hasNext)
+            (0, ui_1.info)(`Next: cku scheduled list --page ${(p.page ?? page) + 1}`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function scheduledQueuedCommand(opts) {
+    try {
+        const res = await (0, dashboardApi_1.dashboardApi)().queuedScheduledCalls();
+        const jobs = res?.scheduleCalls || [];
+        if (opts.json)
+            return void console.log(JSON.stringify(jobs, null, 2));
+        if (!jobs.length)
+            return void (0, ui_1.info)('Nothing queued: no scheduled call is waiting to dial.');
+        // The queue returns jobs in no useful order; soonest first.
+        const due = (j) => (j.timestamp || 0) + (j.delay || 0);
+        jobs.sort((a, b) => due(a) - due(b));
+        (0, ui_1.table)(['JOB ID', 'TO', 'AGENT ID', 'DIALS AT', 'TRY', 'FOLLOW-UP'], jobs.map((j) => [
+            j.id, j.data?.to_number, j.data?.agent_id, when(due(j)),
+            j.data?.try_count ?? '', j.data?.follow_up_call ? 'yes' : '',
+        ]));
+        (0, ui_1.info)(`${jobs.length} queued.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function scheduledGetCommand(id, opts) {
+    try {
+        const res = await (0, dashboardApi_1.dashboardApi)().scheduledCall(id);
+        if (opts.json)
+            return void console.log(JSON.stringify(res, null, 2));
+        const s = res.scheduleCall || {};
+        (0, ui_1.keyValue)({
+            ID: s._id,
+            To: s.to_number,
+            Agent: agentName(s.agent_id),
+            'Scheduled for': s.schedule_at,
+            Language: s.call_language,
+            Retries: s.number_of_retries,
+            'Retry gaps (min)': (s.gap_between_retries || []).join(', '),
+            Window: s.min_trigger_time && `${s.min_trigger_time}–${s.max_trigger_time}`,
+            Batch: s.batch_id || '',
+            Metadata: s.metadata ? JSON.stringify(s.metadata) : '',
+            'Still queued': (res.futureCalls || []).length ? 'yes' : 'no',
+        });
+        const done = res.completedCalls || [];
+        if (done.length) {
+            (0, ui_1.info)('');
+            (0, ui_1.table)(['CALL ID', 'TRY', 'HANGUP', 'DURATION', 'WHEN'], done.map((c) => [c._id, c.try_count ?? '', c.hangup_reason || '', c.call_duration ?? '', when(c.createdAt)]));
+        }
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}

package/dist/commands/simulations.js

@@ -8,6 +8,7 @@ exports.toTestVariables = toTestVariables;
 exports.toTestFunctions = toTestFunctions;
 exports.simTestsListCommand = simTestsListCommand;
 exports.simCreateCommand = simCreateCommand;
+exports.simUpdateCommand = simUpdateCommand;
 exports.simDeleteCommand = simDeleteCommand;
 exports.waitForBatch = waitForBatch;
 exports.simRunCommand = simRunCommand;
@@ -95,6 +96,37 @@ async function simCreateCommand(agentId, opts) {
         (0, ui_1.handleError)(err);
     }
 }
+/**
+ * Edit a test case. Sends only the fields given: the server passes the body to
+ * findByIdAndUpdate as-is, so anything else in it (userId, agentId) would be written.
+ * --variables / --functions replace the whole map / list, they do not merge.
+ */
+async function simUpdateCommand(testCaseId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const body = {};
+        if (opts.name !== undefined)
+            body.testcaseName = opts.name;
+        if (opts.prompt !== undefined)
+            body.userPrompt = opts.prompt;
+        if (opts.criteria !== undefined)
+            body.successCriteria = opts.criteria;
+        if (opts.model !== undefined)
+            body.testLLMModel = opts.model;
+        if (opts.variables !== undefined)
+            body.testVariables = toTestVariables(await (0, jsonInput_1.readJsonFlag)(opts.variables, '--variables'));
+        if (opts.functions !== undefined)
+            body.testFunctions = toTestFunctions(await (0, jsonInput_1.readJsonFlag)(opts.functions, '--functions'));
+        if (!Object.keys(body).length) {
+            return (0, ui_1.handleError)(new Error('Nothing to update. Pass at least one of --name, --prompt, --criteria, --model, --variables, --functions.'));
+        }
+        const res = await api.updateTestCase(testCaseId, body);
+        (0, ui_1.success)(`Updated test case ${res.testCase?._id || testCaseId}: ${Object.keys(body).join(', ')}.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
 async function simDeleteCommand(testCaseId, opts) {
     const api = (0, session_1.requireApi)();
     try {

package/dist/index.js

@@ -16,6 +16,8 @@ const KPI_COLUMNS = 'action_items | in_progress | testing_ab | live_prod | done
 const analyzers_1 = require("./commands/analyzers");
 const models_1 = require("./commands/models");
 const agents_1 = require("./commands/agents");
+const agentChat_1 = require("./commands/agentChat");
+const scheduled_1 = require("./commands/scheduled");
 const agentVersions_1 = require("./commands/agentVersions");
 const agentPhone_1 = require("./commands/agentPhone");
 const whatsapp_1 = require("./commands/whatsapp");
@@ -40,6 +42,11 @@ const chatAgents_1 = require("./commands/chatAgents");
 // last silently wins. `cku` cannot collide.
 const name = 'cku';
 const { version: VERSION } = require('../package.json');
+/** Collect repeatable flag values (--var, --say, --postcall) into an array. */
+const collectVar = (val, acc) => {
+    acc.push(val);
+    return acc;
+};
 const program = new commander_1.Command();
 program
     .name(name)
@@ -330,6 +337,27 @@ agents.command('get <agentId>').description('show one agent and list its version
     .option('--json', 'output raw JSON')
     .option('--file <path>', 'save the agent detail as JSON to a file')
     .action(agents_1.agentsGetCommand);
+agents.command('chat <agentId>')
+    .description('text-chat with an agent, no phone call (custom in-call functions RUN FOR REAL)')
+    .option('--versions <id>', 'version to talk to (default: the published one)')
+    .option('--metadata <json|@file>', 'call metadata as a JSON object')
+    .option('--var <k=v>', 'call metadata variable (repeatable)', collectVar, [])
+    .option('--say <text>', 'user turn, repeatable, run in order; no terminal needed', collectVar, [])
+    .option('--history <json|@file>', 'replay a saved conversation (the output of --json) before --say')
+    .option('--save <file>', 'write the conversation to a file at the end (readable by --history)')
+    .option('--show-prompt', 'print the rendered system prompt once (checks metadata substitution)')
+    .option('--json', 'print only the final conversation as JSON')
+    .addHelpText('after', `
+Not mocked: any custom in-call function. It really runs (CRM write, webhook, WhatsApp).
+Mocked: end_call, transfer_call, warm_transfer, keep_call_on_hold, use_knowledge_base,
+  change_conversation_language, send_booking_link_to_whatsapp, collect_digits_via_dtmf.
+
+Examples:
+  cku agents chat <agentId>
+  cku agents chat <agentId> --var customer_name=Ravi --say "Hello?" --say "Not interested"
+  cku agents chat <agentId> --say "hi" --json > convo.json
+  cku agents chat <agentId> --history @convo.json --say "What was that again?"`)
+    .action(agentChat_1.agentChatCommand);
 agents.command('versions <agentId>').description("list an agent's versions (name, id, language, prompt type, active)")
     .option('--json', 'output raw JSON')
     .option('--file <path>', 'save the version list as JSON to a file')
@@ -494,13 +522,11 @@ function addCallFilters(cmd) {
         .option('--to <number>', 'destination number')
         .option('--converted <bool>', 'conversion status: true|false')
         .option('--lead <id>', 'lead id')
-        .option('--buylead <value>', 'buylead value');
+        .option('--buylead <value>', 'buylead value')
+        .option('--postcall <name=bool>', 'boolean post-call variable, repeatable: dnc_requested=true', collectVar, [])
+        .option('--provider-type <list>', 'telephony provider(s), comma-separated: plivo,vobiz,...')
+        .option('--sid <callSid>', 'provider call SID (ignores the date window)');
 }
-/** Collect repeatable --var key=value into an array. */
-const collectVar = (val, acc) => {
-    acc.push(val);
-    return acc;
-};
 // --- voices / transcribers -------------------------------------------------
 program
     .command('voices')
@@ -543,6 +569,20 @@ program
     .option('--all', 'include admin-gated providers')
     .option('--json', 'raw JSON')
     .action(transcribers_1.transcribersCommand);
+// --- scheduled calls (dashboard cookie) -------------------------------------
+const scheduled = program.command('scheduled')
+    .description('scheduled calls, read-only (needs `cku dashboard login`)');
+scheduled.command('list').description('schedule records, newest first')
+    .option('--page <n>', 'page number (default 1)')
+    .option('--limit <n>', 'page size (default 50)')
+    .option('--json', 'raw JSON (a bare array)')
+    .action(scheduled_1.scheduledListCommand);
+scheduled.command('queued').description('jobs waiting in the queue: what will actually dial, soonest first')
+    .option('--json', 'raw JSON (a bare array of queue jobs)')
+    .action(scheduled_1.scheduledQueuedCommand);
+scheduled.command('get <id>').description('one schedule record, its completed tries, and whether it is still queued')
+    .option('--json', 'raw JSON')
+    .action(scheduled_1.scheduledGetCommand);
 // --- calls -----------------------------------------------------------------
 const calls = program.command('calls').description('calls: place & history');
 calls.command('make').description('place a single outbound call (real, or --test)')
@@ -656,6 +696,14 @@ sim.command('create <agentId>').description('create a test case')
     .option('--variables <json|@file>', 'testVariables: a JSON object of name -> value (non-strings are stringified)')
     .option('--functions <json|@file>', 'function mocks: a JSON array of {"name": ..., "response": ...}')
     .action(simulations_1.simCreateCommand);
+sim.command('update <testCaseId>').description('edit a test case (only the fields you pass are sent)')
+    .option('--name <name>', 'test case name')
+    .option('--prompt <text>', 'simulated user prompt')
+    .option('--criteria <text>', 'success criteria')
+    .option('--model <model>', 'test LLM model')
+    .option('--variables <json|@file>', 'testVariables: replaces the whole map')
+    .option('--functions <json|@file>', 'function mocks: replaces the whole list')
+    .action(simulations_1.simUpdateCommand);
 sim.command('delete <testCaseId>').description('delete a test case').option('--yes', 'skip confirmation')
     .action(simulations_1.simDeleteCommand);
 sim.command('run <agentId>').description('run a batch simulation (async)')

package/dist/lib/api.js

@@ -250,6 +250,11 @@ class Api {
     listTestCases(agentId) {
         return this.request('GET', `/cli/simulations/test-cases${qs({ agentId })}`);
     }
+    /** One agent turn from a chat history, no telephony (`agents chat`). */
+    generateReply(body, versionId) {
+        const q = versionId ? `?version=${encodeURIComponent(versionId)}` : '';
+        return this.request('POST', `/cli/simulations/generate-reply${q}`, body);
+    }
     updateTestCase(id, body) { return this.request('PUT', `/cli/simulations/test-cases/${id}`, body); }
     deleteTestCase(id) { return this.request('DELETE', `/cli/simulations/test-cases/${id}`); }
     runSimulation(body) { return this.request('POST', '/cli/simulations/runs', body); }

package/dist/lib/dashboardApi.js

@@ -144,6 +144,22 @@ class DashboardApi {
     deleteTestVariableSet(id) {
         return this.request('DELETE', `/v1/call-metadata-test-variables/${encodeURIComponent(id)}`);
     }
+    // --- scheduled calls (read-only) -------------------------------------------
+    // The delete routes under /schedulecalls/v1 are deliberately not wrapped: the
+    // single-call one re-schedules a new attempt rather than cancelling, and neither
+    // checks that the job belongs to the caller. See docs/plan-unused-routes.md.
+    /** Schedule records, newest first. 44k rows on a busy account: always paged. */
+    scheduledCalls(query = {}) {
+        return this.request('GET', `/schedulecalls/v1/all${qs(query)}`);
+    }
+    /** Pending jobs in the queue: what will actually dial, with `data.schedule_at`. */
+    queuedScheduledCalls() {
+        return this.request('GET', '/schedulecalls/v1/queued-scheduled-calls/all');
+    }
+    /** One schedule record plus the calls it produced and any pending job. */
+    scheduledCall(id) {
+        return this.request('GET', `/schedulecalls/v1/${encodeURIComponent(id)}`);
+    }
     // --- KPI board writes -----------------------------------------------------
     //
     // Routes, bodies and the column set below were read out of the dashboard's own

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "callkaro-cli-unofficial",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "license": "Apache-2.0",
   "description": "Unofficial fork of the CallKaro CLI — manage your voice AI agents from the terminal",
   "bin": {