callkaro-cli-unofficial 0.6.1 → 0.7.0

package/README.md

@@ -205,6 +205,7 @@ npm run catalog:check    # fail if catalog.json disagrees with the snapshot
 - `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 chat-sim` — simulations and test cases for chat agents (official 5.4.0); `cku chat-audit-strategies` — AI Auditor for WhatsApp agents, including `batch` to audit conversations now
 - `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**

package/dist/commands/chatAuditStrategies.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chatAuditListCommand = chatAuditListCommand;
+exports.chatAuditGetCommand = chatAuditGetCommand;
+exports.chatAuditModelsCommand = chatAuditModelsCommand;
+exports.chatAuditCreateCommand = chatAuditCreateCommand;
+exports.chatAuditUpdateCommand = chatAuditUpdateCommand;
+exports.chatAuditDeleteCommand = chatAuditDeleteCommand;
+exports.chatAuditBatchCommand = chatAuditBatchCommand;
+const session_1 = require("../lib/session");
+const ui_1 = require("../lib/ui");
+const setJson_1 = require("./setJson");
+// Mirrors the backend's /cli/chat-audit-strategies. It keeps every field not sent on update,
+// so no client-side merge is needed (unlike the voice audit strategies).
+/** A numeric flag, or undefined when absent. NaN would serialise to null and be silently accepted. */
+function numericFlag(raw, flag) {
+    if (raw === undefined || raw === null || raw === '')
+        return undefined;
+    const n = Number(raw);
+    if (!Number.isFinite(n))
+        throw new Error(`${flag} must be a number (got "${raw}").`);
+    return n;
+}
+function buildFields(opts) {
+    return (0, setJson_1.pruneUndefined)({
+        ...(opts.set ? (0, setJson_1.readSetJson)(opts.set) : {}),
+        name: opts.name,
+        audit_strategy: opts.strategy,
+        active: opts.disable ? false : opts.active,
+        llms: opts.model ? { name: opts.model } : undefined,
+        percentage_per_day: numericFlag(opts.pctPerDay, '--pct-per-day'),
+        max_conversations_per_day: numericFlag(opts.maxPerDay, '--max-per-day'),
+        min_user_messages: numericFlag(opts.minUserMessages, '--min-user-messages'),
+        min_messages: numericFlag(opts.minMessages, '--min-messages'),
+    });
+}
+async function chatAuditListCommand(agentId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const rows = (await api.listChatAuditStrategies(agentId)).strategies || [];
+        if (opts.json)
+            return void console.log(JSON.stringify(rows, null, 2));
+        if (!rows.length)
+            return void (0, ui_1.info)('No chat audit strategies yet.');
+        (0, ui_1.table)(['NAME', 'ID', 'ACTIVE'], rows.map((s) => [s.name || '', s._id, s.active ? 'yes' : 'no']));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function chatAuditGetCommand(agentId, strategyId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const strategy = ((await api.listChatAuditStrategies(agentId)).strategies || []).find((s) => s._id === strategyId);
+        if (!strategy)
+            return (0, ui_1.handleError)(new Error(`Chat audit strategy ${strategyId} not found for agent ${agentId}.`));
+        if (opts.json)
+            return void console.log(JSON.stringify(strategy, null, 2));
+        (0, ui_1.keyValue)({
+            name: strategy.name,
+            id: strategy._id,
+            active: strategy.active,
+            audit_strategy: strategy.audit_strategy,
+            llms: JSON.stringify(strategy.llms),
+            audit_filters: JSON.stringify(strategy.audit_filters),
+            percentage_per_day: strategy.percentage_per_day,
+            max_conversations_per_day: strategy.max_conversations_per_day,
+        });
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function chatAuditModelsCommand(agentId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const rows = (await api.listChatAuditStrategies(agentId)).models || [];
+        if (opts.json)
+            return void console.log(JSON.stringify(rows, null, 2));
+        (0, ui_1.table)(['MODEL'], rows.map((m) => [m]));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function chatAuditCreateCommand(agentId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const fields = buildFields(opts);
+        if (!fields.audit_strategy) {
+            throw new Error('audit_strategy is required: pass --strategy <text> or --set \'{"audit_strategy":"..."}\'');
+        }
+        const res = await api.createChatAuditStrategy({ agentId, ...fields });
+        (0, ui_1.success)(`Created chat audit strategy ${res.strategy?._id || ''}.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function chatAuditUpdateCommand(agentId, strategyId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const res = await api.updateChatAuditStrategy(strategyId, { agentId, ...buildFields(opts) });
+        (0, ui_1.success)(res.message || `Updated chat audit strategy ${strategyId}.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function chatAuditDeleteCommand(strategyId) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const res = await api.deleteChatAuditStrategy(strategyId);
+        (0, ui_1.success)(res.message || `Deleted chat audit strategy ${strategyId}.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function chatAuditBatchCommand(agentId, strategyId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const max = numericFlag(opts.max, '--max');
+        if (max === undefined || !Number.isInteger(max) || max < 1 || max > 500) {
+            throw new Error('--max must be a whole number from 1 to 500');
+        }
+        const res = await api.createChatAuditBatch({
+            ...(opts.set ? (0, setJson_1.readSetJson)(opts.set) : {}),
+            agentId,
+            strategyId,
+            maxConversations: max,
+            ...(0, setJson_1.pruneUndefined)({ phone: opts.phone, llm: opts.model ? { name: opts.model } : undefined }),
+        });
+        (0, ui_1.success)(`${res.message || 'Batch created'}${res.data?.batchId ? ` (batch ${res.data.batchId})` : ''}.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}

package/dist/commands/chatSimulations.js

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chatTestCaseBody = chatTestCaseBody;
+exports.evaluationOf = evaluationOf;
+exports.chatSimTestsListCommand = chatSimTestsListCommand;
+exports.chatSimCreateCommand = chatSimCreateCommand;
+exports.chatSimUpdateCommand = chatSimUpdateCommand;
+exports.chatSimDeleteCommand = chatSimDeleteCommand;
+exports.chatSimRunCommand = chatSimRunCommand;
+exports.chatSimRunsListCommand = chatSimRunsListCommand;
+exports.chatSimResultsCommand = chatSimResultsCommand;
+const prompts_1 = __importDefault(require("prompts"));
+const session_1 = require("../lib/session");
+const ui_1 = require("../lib/ui");
+const jsonInput_1 = require("./jsonInput");
+// The dashboard's pass mark: successRating out of 10.
+const PASS_RATING = 7;
+/** Only the fields given. `enabled: false` on a mock runs the agent's real function. */
+async function chatTestCaseBody(opts) {
+    const body = {
+        test_case_name: opts.name,
+        user_persona: opts.persona,
+        user_prompt: opts.prompt,
+        success_criteria: opts.criteria,
+        primary_user_model: opts.model,
+        secondary_user_model: opts.secondaryModel,
+    };
+    if (opts.mocks !== undefined) {
+        const mocks = await (0, jsonInput_1.readJsonFlag)(opts.mocks, '--mocks');
+        if (!Array.isArray(mocks))
+            throw new Error('--mocks must be a JSON array of {"name", "response"?, "enabled"?}.');
+        body.function_mocks = mocks.map((m, i) => {
+            if (!m || typeof m.name !== 'string' || !m.name)
+                throw new Error(`--mocks[${i}] needs a "name" (string).`);
+            return {
+                name: m.name,
+                ...(m.response === undefined ? {} : { response: m.response }),
+                ...(m.enabled === undefined ? {} : { enabled: m.enabled }),
+            };
+        });
+    }
+    return Object.fromEntries(Object.entries(body).filter(([, v]) => v !== undefined));
+}
+async function defaultChatModel() {
+    const res = await (0, session_1.requireApi)().listChatAgentModels();
+    return res.categories?.[0]?.defaultModel || res.models?.[0]?.id;
+}
+function evaluationOf(sim) {
+    const evaluation = Array.isArray(sim.post_simulation) ? sim.post_simulation[0] : null;
+    const raw = evaluation?.successRating;
+    const rating = raw === null || raw === undefined || raw === '' ? NaN : Number(raw);
+    if (!evaluation || !Number.isFinite(rating))
+        return { rating: null, result: 'GRADING FAILED', flaws: '' };
+    return { rating, result: rating >= PASS_RATING ? 'PASS' : 'FAIL', flaws: evaluation.successFlaws || '' };
+}
+async function chatSimTestsListCommand(chatAgentId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const rows = (await api.listChatTestCases(chatAgentId)).testCases || [];
+        if (opts.json)
+            return void console.log(JSON.stringify(rows, null, 2));
+        if (!rows.length)
+            return void (0, ui_1.info)('No chat test cases yet.');
+        (0, ui_1.table)(['NAME', 'ID', 'USER MODEL'], rows.map((t) => [t.test_case_name || '', t._id, t.primary_user_model || '']));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function chatSimCreateCommand(chatAgentId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        // Parse --mocks before prompting, so a typo fails before any typing.
+        const body = await chatTestCaseBody(opts);
+        let { name, persona, prompt, criteria } = opts;
+        if (!name || !prompt || !criteria) {
+            (0, ui_1.needTty)('Pass --name, --prompt and --criteria.');
+            const answers = await (0, prompts_1.default)([
+                { type: name ? null : 'text', name: 'name', message: 'Test case name' },
+                { type: persona ? null : 'text', name: 'persona', message: 'User persona (who they are, tone, what they know)' },
+                { type: prompt ? null : 'text', name: 'prompt', message: 'Simulated user prompt (goal, beats, rules)' },
+                { type: criteria ? null : 'text', name: 'criteria', message: 'Success criteria' },
+            ], { onCancel: () => process.exit(1) });
+            name = name || answers.name;
+            persona = persona || answers.persona;
+            prompt = prompt || answers.prompt;
+            criteria = criteria || answers.criteria;
+        }
+        if (!name || !prompt || !criteria) {
+            return (0, ui_1.handleError)(new Error('--name, --prompt and --criteria are all required (or answer the prompts)'));
+        }
+        const res = await api.createChatTestCase({
+            ...body,
+            chat_agent_id: chatAgentId,
+            test_case_name: name,
+            ...(persona ? { user_persona: persona } : {}),
+            user_prompt: prompt,
+            success_criteria: criteria,
+            primary_user_model: opts.model || (await defaultChatModel()),
+        });
+        (0, ui_1.success)(`Created chat test case ${res.testCase?._id || ''} (user model: ${res.testCase?.primary_user_model || ''}).`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** Sends only the passed fields; --mocks replaces the whole list. */
+async function chatSimUpdateCommand(testCaseId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const body = await chatTestCaseBody(opts);
+        if (!Object.keys(body).length) {
+            throw new Error('Nothing to update: pass at least one of --name --persona --prompt --criteria --model --secondary-model --mocks');
+        }
+        await api.updateChatTestCase(testCaseId, body);
+        (0, ui_1.success)(`Updated chat test case ${testCaseId}.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function chatSimDeleteCommand(testCaseId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        if (!(await (0, ui_1.confirm)(`Delete chat test case ${testCaseId}?`, opts.yes)))
+            return;
+        const res = await api.deleteChatTestCase(testCaseId);
+        (0, ui_1.success)(res.msg || 'Deleted.');
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+const ids = (raw) => (raw || '').split(',').map((s) => s.trim()).filter(Boolean);
+async function chatSimRunCommand(chatAgentId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const testIds = ids(opts.tests);
+        const versionIds = ids(opts.versions);
+        if (!testIds.length)
+            throw new Error('--tests <testCaseIds> is required');
+        if (!versionIds.length)
+            throw new Error('--versions <versionIds> is required');
+        const epochs = (0, ui_1.intFlag)(opts.epochs, '--epochs', 1);
+        if (epochs < 1 || epochs > 100)
+            throw new Error('--epochs must be between 1 and 100');
+        const res = await api.runChatSimulation({
+            chat_agent_id: chatAgentId,
+            test_case_ids: testIds,
+            chat_version_ids: versionIds,
+            batch_name: opts.name || `cku-run-${Date.now()}`,
+            epochs,
+        });
+        (0, ui_1.success)(`Chat simulation run started (${res.batch?._id || ''}, ${res.batch?.number_of_runs ?? '?'} runs). Results arrive asynchronously.`);
+        (0, ui_1.info)(`Check with: cku chat-sim results ${res.batch?._id || '<runId>'}`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function chatSimRunsListCommand(chatAgentId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const res = await api.listChatSimulationRuns(chatAgentId);
+        const rows = res.batches || [];
+        if (opts.json)
+            return void console.log(JSON.stringify(rows, null, 2));
+        if (!rows.length)
+            return void (0, ui_1.info)('No chat simulation runs yet.');
+        (0, ui_1.table)(['NAME', 'ID', 'RUNS', 'CREATED'], rows.map((b) => [b.batch_name || '', b._id, String(b.number_of_runs ?? ''), b.createdAt || '']));
+        if (typeof res.totalCost === 'number')
+            console.log(`Total cost, all runs: ${res.totalCost > 0 ? res.totalCost.toFixed(3) : 'N/A'}`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function chatSimResultsCommand(runId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const res = await api.chatSimulationResults(runId);
+        const rows = res.simulations || [];
+        if (opts.json)
+            return void console.log(JSON.stringify(res, null, 2));
+        if (!rows.length)
+            return void (0, ui_1.info)('No results yet (the run may still be in progress).');
+        // Names are best-effort; a deleted test case still shows by id.
+        let names = new Map();
+        try {
+            const tc = await api.listChatTestCases(res.batch?.chat_agent_id);
+            names = new Map((tc.testCases || []).map((t) => [t._id, t.test_case_name]));
+        }
+        catch {
+            // ids are enough
+        }
+        (0, ui_1.table)(['TEST CASE', 'VERSION', 'RESULT', 'RATING', 'FLAWS', 'ID'], rows.map((s) => {
+            const e = evaluationOf(s);
+            return [
+                names.get(s.test_case_id) || s.test_case_id || '',
+                s.chat_agent_version_id || '',
+                e.result,
+                e.rating === null ? '' : `${e.rating}/10`,
+                e.flaws.slice(0, 60),
+                s._id,
+            ];
+        }));
+        const expected = res.batch?.number_of_runs;
+        if (expected && rows.length < expected)
+            (0, ui_1.info)(`${rows.length} of ${expected} runs finished; the rest are still running.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}

package/dist/commands/contacts.js

@@ -205,8 +205,6 @@ async function assignDryRun(api, opts, phones, q) {
     if (opts.workflow) {
         const wf = await api.getWorkflow(opts.workflow);
         const steps = wf.graph?.nodes?.length ?? 0;
-        if (wf.type && wf.type !== 'normal')
-            throw new Error('This workflow is deprecated and cannot take contacts.');
         if (!steps)
             throw new Error(`Workflow "${wf.workFlowName}" has no steps yet; the server would refuse this assign.`);
         target = `workflow "${wf.workFlowName}" (${steps} nodes)`;

package/dist/commands/simulations.js

@@ -34,16 +34,25 @@ function toTestVariables(input) {
     }
     return out;
 }
-/** `testFunctions` is a list of `{name, response}` mocks; `response` is an object or a string. */
+/**
+ * `testFunctions` is a list of `{name, mock?, response?}`. `mock: false` runs the agent's REAL
+ * function instead of the canned response (official 5.4.0); never for WhatsApp functions.
+ */
 function toTestFunctions(input) {
     if (!Array.isArray(input)) {
-        throw new Error('--functions must be a JSON array of {"name": ..., "response": ...} mocks.');
+        throw new Error('--functions must be a JSON array of {"name": ..., "mock"?: bool, "response"?: ...}.');
     }
     return input.map((f, i) => {
-        if (!f || typeof f !== 'object' || typeof f.name !== 'string' || !f.name || !('response' in f)) {
-            throw new Error(`--functions[${i}] needs a "name" (string) and a "response" (object or string).`);
+        if (!f || typeof f !== 'object' || typeof f.name !== 'string' || !f.name) {
+            throw new Error(`--functions[${i}] needs a "name" (string).`);
+        }
+        if (f.mock !== undefined && typeof f.mock !== 'boolean') {
+            throw new Error(`--functions[${i}].mock must be true or false.`);
+        }
+        if (f.mock !== false && !('response' in f)) {
+            throw new Error(`--functions[${i}] needs a "response" (object or string), or "mock": false to run the real function.`);
         }
-        return { name: f.name, response: f.response };
+        return { name: f.name, ...(f.mock === undefined ? {} : { mock: f.mock }), ...('response' in f ? { response: f.response } : {}) };
     });
 }
 async function simTestsListCommand(agentId, opts) {

package/dist/commands/workflows.js

@@ -66,15 +66,39 @@ const HANGUP_REASONS = [
 ];
 const NODE_REFERENCE = `Workflow graph: { "nodes": [...], "edges": [...] }
 
-Every node: { id (unique), type, name, x, y }. Exactly one "start"; at least one
-"end" must be reachable from it. Nothing may lead into start or out of an end.
+Every node: { id (unique), type, name, x, y }. Exactly one "start"; an "end" or
+"cancel" must be reachable from it. At most one "inbound", the second entry
+point. Nothing may lead into start or inbound, and nothing may follow end,
+cancel or resume.
 
 Node types — required fields, then a sample (x/y optional)
 These are the only types; the dashboard's Add Node menu offers exactly these:
-  End = end · Send Call = send-call · Send WhatsApp Template = wa-template ·
-  Send WhatsApp Message = wa-message · Wait = wait · Conditions = conditions ·
-  API Call — Basic = api-basic · API Call — Advanced = api-advanced ·
-  Update Contact = update-lead   (Start is created with the workflow, never added)
+  Inbound Call = inbound · End = end · Cancel Workflow = cancel ·
+  Resume Where They Were = resume · Send Call = send-call ·
+  Send WhatsApp Template = wa-template · Send WhatsApp Message = wa-message ·
+  Wait = wait · Conditions = conditions · API Call — Basic = api-basic ·
+  API Call — Advanced = api-advanced · Update Contact = update-lead
+  (Start is created with the workflow, never added)
+
+Inbound calls — the second entry point
+  When a lead calls in on a number this workflow has called them from, their
+  live run JUMPS to the inbound node from wherever it had reached, and carries
+  on down that branch. Conditions placed after it read THAT call.
+  What the branch leads to decides the journey they were on:
+    reaches cancel  -> cancelled, and any scheduled call is dropped
+    reaches end     -> completed
+    reaches resume  -> back to the step the call interrupted (a wait keeps the
+                       time it had left)
+    leads nowhere   -> the same as resume. An inbound node with no outgoing
+                       edge is valid: the call is recorded against the run and
+                       the lead left exactly where they were.
+
+  inbound       no fields; at most one per workflow; nothing may lead into it
+    {"id":"inbound-1","type":"inbound","name":"Inbound Call","x":320,"y":600}
+  cancel        no fields; ends the run as "cancelled" and drops its queued calls
+    {"id":"cancel-1","type":"cancel","name":"Cancel Workflow","x":1600,"y":600}
+  resume        no fields; needs an inbound node in the same workflow
+    {"id":"resume-1","type":"resume","name":"Resume Where They Were","x":1600,"y":760}
 
   start         {"id":"start-1","type":"start","name":"Start","x":320,"y":180}
   end           {"id":"end-1","type":"end","name":"End","x":2400,"y":180}
@@ -290,7 +314,7 @@ async function workflowsExportCommand(id, opts) {
             type: 'callkaro_workflow',
             version: 1,
             exportedAt: new Date().toISOString(),
-            data: { workFlowName: wf.workFlowName, type: 'normal', graph: wf.graph ?? { nodes: [], edges: [] } },
+            data: { workFlowName: wf.workFlowName, graph: wf.graph ?? { nodes: [], edges: [] } },
         };
         if (opts.file) {
             (0, fs_1.writeFileSync)(opts.file, JSON.stringify(payload, null, 2));
@@ -402,8 +426,6 @@ async function editGraph(id, apply) {
     const api = (0, session_1.requireApi)();
     try {
         const wf = await api.getWorkflow(id);
-        if (wf.type && wf.type !== 'normal')
-            throw new Error('This workflow is deprecated and cannot be edited.');
         const graph = {
             nodes: JSON.parse(JSON.stringify(wf.graph?.nodes ?? [])),
             edges: JSON.parse(JSON.stringify(wf.graph?.edges ?? [])),

package/dist/index.js

@@ -4,6 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const chatSimulations_1 = require("./commands/chatSimulations");
+const chatAuditStrategies_1 = require("./commands/chatAuditStrategies");
 const commander_1 = require("commander");
 const chalk_1 = __importDefault(require("chalk"));
 const ui_1 = require("./lib/ui");
@@ -491,7 +493,7 @@ workflows.command('leads <id>').description('leads enrolled in a workflow and wh
 workflows.command('lead <id> <phone>').description("one lead's call totals and enrolment time in a workflow").option('--json', 'output raw JSON').option('--file <path>', 'save JSON to a file').action(workflows_1.workflowsLeadCommand);
 workflows.command('run <id> <phone>').description("a lead's latest run, step by step").option('--json', 'full detail incl. step results and variables').option('--file <path>', 'save JSON to a file').action(workflows_1.workflowsRunCommand);
 workflows.command('journey <id> <phone>').description('every call to or from a number inside this workflow').option('--json', 'output raw JSON').option('--file <path>', 'save JSON to a file').action(workflows_1.workflowsJourneyCommand);
-workflows.command('add-node <id>').description('add a node; with --after it is spliced into the chain after that node').requiredOption('--type <type>', 'send-call | wa-template | wa-message | wait | conditions | api-basic | api-advanced | update-lead | end').option('--name <name>', 'node name').option('--set <json>', 'extra fields as JSON or @file.json, e.g. \'{"minutes":5}\'').option('--after <nodeId>', 'insert after this node').option('--handle <handle>', 'which branch of --after (conditions exit id)').option('--x <n>', 'canvas x').option('--y <n>', 'canvas y').action(workflows_1.workflowsAddNodeCommand);
+workflows.command('add-node <id>').description('add a node; with --after it is spliced into the chain after that node').requiredOption('--type <type>', 'inbound | send-call | wa-template | wa-message | wait | conditions | api-basic | api-advanced | update-lead | end | cancel | resume').option('--name <name>', 'node name').option('--set <json>', 'extra fields as JSON or @file.json, e.g. \'{"minutes":5}\'').option('--after <nodeId>', 'insert after this node').option('--handle <handle>', 'which branch of --after (conditions exit id)').option('--x <n>', 'canvas x').option('--y <n>', 'canvas y').action(workflows_1.workflowsAddNodeCommand);
 workflows.command('set-node <id> <nodeId>').description("change a node's fields (merged; id and type are fixed)").option('--set <json>', 'fields as JSON or @file.json').option('--name <name>', 'rename').action(workflows_1.workflowsSetNodeCommand);
 workflows.command('remove-node <id> <nodeId>').description('remove a node and its edges').option('--reconnect', 'link what led into it to what it led to').option('--yes', 'skip confirmation').action(workflows_1.workflowsRemoveNodeCommand);
 workflows.command('connect <id>').description('link a node to another (replaces any existing link from that handle)').requiredOption('--from <nodeId>', 'source node').requiredOption('--to <nodeId>', 'target node').option('--handle <handle>', 'source branch (conditions exit id); default "out"').action(workflows_1.workflowsConnectCommand);
@@ -590,15 +592,15 @@ agents.command('chat <agentId>')
     .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
+    .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)")
@@ -938,7 +940,7 @@ sim.command('create <agentId>').description('create a test case')
     .option('--criteria <text>', 'success criteria')
     .option('--model <model>', 'test LLM model (default: platform default; see `cku sim models`)')
     .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": ...}')
+    .option('--functions <json|@file>', 'a JSON array of {"name":"fn","mock":true,"response":{}}; "mock":false runs the REAL function (never for WhatsApp functions)')
     .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')
@@ -947,7 +949,7 @@ sim.command('update <testCaseId>').description('edit a test case (only the field
     .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')
+    .option('--functions <json|@file>', 'function list, replaces the whole list; entries are {name, mock?, response?}, "mock":false runs the REAL function')
     .action(simulations_1.simUpdateCommand);
 sim.command('models').description('models that can play the simulated caller').option('--json', 'raw JSON').action(simulations_1.simModelsCommand);
 sim.command('delete <testCaseId>').description('delete a test case').option('--yes', 'skip confirmation')
@@ -979,6 +981,71 @@ simVars.command('create <agentId> <name>').description('save a variable set')
 simVars.command('delete <agentId> <nameOrId>').description('delete a saved set').option('--yes', 'skip confirmation')
     .action(simVariables_1.simVarsDeleteCommand);
 // --- audit strategies ------------------------------------------------------
+const chatSim = program.command('chat-sim').description('chat agent simulations & test cases');
+chatSim.command('tests <chatAgentId>').description('list chat test cases').option('--json', 'raw JSON').action(chatSimulations_1.chatSimTestsListCommand);
+chatSim.command('create <chatAgentId>').description('create a chat test case')
+    .option('--name <name>', 'test case name')
+    .option('--persona <text>', 'who the simulated user is')
+    .option('--prompt <text>', 'simulated user prompt')
+    .option('--criteria <text>', 'success criteria')
+    .option('--model <model>', 'model that plays the user (default: chat default; see `cku chat-agents models`)')
+    .option('--secondary-model <model>', 'fallback model if the primary fails to reply')
+    .option('--mocks <json|@file>', 'custom-function mocks: [{"name":"fn","response":{},"enabled":true}]; "enabled":false runs the real function')
+    .action(chatSimulations_1.chatSimCreateCommand);
+chatSim.command('update <testCaseId>').description('update a chat test case (only the flags you pass change)')
+    .option('--name <name>', 'test case name')
+    .option('--persona <text>', 'who the simulated user is')
+    .option('--prompt <text>', 'simulated user prompt')
+    .option('--criteria <text>', 'success criteria')
+    .option('--model <model>', 'model that plays the user')
+    .option('--secondary-model <model>', 'fallback model')
+    .option('--mocks <json|@file>', 'custom-function mocks, replaces the whole list; "enabled":false runs the real function')
+    .action(chatSimulations_1.chatSimUpdateCommand);
+chatSim.command('delete <testCaseId>').description('delete a chat test case').option('--yes', 'skip confirmation').action(chatSimulations_1.chatSimDeleteCommand);
+chatSim.command('run <chatAgentId>').description('run a chat simulation batch (async)')
+    .option('--tests <ids>', 'comma-separated test case ids')
+    .option('--versions <ids>', 'comma-separated chat agent version ids')
+    .option('--name <name>', 'run name')
+    .option('--epochs <n>', 'times to run each test/version pair (default 1, max 100)')
+    .action(chatSimulations_1.chatSimRunCommand);
+chatSim.command('runs <chatAgentId>').description('list chat simulation runs').option('--json', 'raw JSON').action(chatSimulations_1.chatSimRunsListCommand);
+chatSim.command('results <runId>').description('results of a chat simulation run').option('--json', 'raw JSON').action(chatSimulations_1.chatSimResultsCommand);
+const chatAudit = program.command('chat-audit-strategies').alias('chat-audit')
+    .description('AI Auditor strategies for WhatsApp chat agents');
+chatAudit.command('list <agentId>').description('list chat audit strategies for a WhatsApp agent').option('--json', 'raw JSON').action(chatAuditStrategies_1.chatAuditListCommand);
+chatAudit.command('get <agentId> <strategyId>').description('show one chat audit strategy').option('--json', 'raw JSON').action(chatAuditStrategies_1.chatAuditGetCommand);
+chatAudit.command('models <agentId>').description('list models chat audits may run on').option('--json', 'raw JSON').action(chatAuditStrategies_1.chatAuditModelsCommand);
+chatAudit.command('create <agentId>').description('create a chat audit strategy')
+    .option('--name <name>', 'strategy name')
+    .option('--strategy <text>', 'free-text audit instructions for the LLM auditor (required)')
+    .option('--active', 'activate immediately (default: inactive)')
+    .option('--model <name>', 'audit model, from `cku chat-audit models <agentId>`')
+    .option('--pct-per-day <n>', 'percent of eligible conversations audited each day')
+    .option('--max-per-day <n>', 'max conversations audited per day, 0 = no cap (set this or --pct-per-day)')
+    .option('--min-user-messages <n>', 'skip conversations with fewer customer messages (default 1)')
+    .option('--min-messages <n>', 'skip conversations with fewer total messages (default 2)')
+    .option('--set <json|@file>', 'JSON for audit_filters/extra_variables/llms; attribute names/values: `cku contacts attributes list`')
+    .action(chatAuditStrategies_1.chatAuditCreateCommand);
+chatAudit.command('update <agentId> <strategyId>').description('update a chat audit strategy (only named fields change)')
+    .option('--name <name>', 'strategy name')
+    .option('--strategy <text>', 'free-text audit instructions for the LLM auditor')
+    .option('--active', 'activate the strategy')
+    .option('--disable', 'deactivate the strategy')
+    .option('--model <name>', 'audit model, from `cku chat-audit models <agentId>`')
+    .option('--pct-per-day <n>', 'percent of eligible conversations audited each day')
+    .option('--max-per-day <n>', 'max conversations audited per day, 0 = no cap')
+    .option('--min-user-messages <n>', 'skip conversations with fewer customer messages')
+    .option('--min-messages <n>', 'skip conversations with fewer total messages')
+    .option('--set <json|@file>', 'JSON for audit_filters/extra_variables/llms; each replaces the stored value')
+    .action(chatAuditStrategies_1.chatAuditUpdateCommand);
+chatAudit.command('delete <strategyId>').description('delete a chat audit strategy').action(chatAuditStrategies_1.chatAuditDeleteCommand);
+chatAudit.command('batch <agentId> <strategyId>')
+    .description('audit up to N conversations now (uses credits; only messages since each last audit)')
+    .requiredOption('--max <n>', 'number of conversations to audit (1-500)')
+    .option('--phone <number>', "audit only this customer's number, with country code")
+    .option('--model <name>', 'audit model for this batch only')
+    .option('--set <json|@file>', 'JSON with filters/minUserMessages/minMessages')
+    .action(chatAuditStrategies_1.chatAuditBatchCommand);
 const audit = program.command('audit-strategies').alias('audit').description('AI Auditor audit strategies');
 audit.command('list <agentId>').description('list audit strategies for an agent').option('--json', 'raw JSON')
     .action(auditStrategies_1.auditListCommand);
@@ -1011,18 +1078,18 @@ audit.command('update <agentId> <strategyId>').description('update an audit stra
     .option('--retranscribe', 'retranscribe audio before auditing')
     .option('--set <json>', 'JSON (or @file.json) for audit_filters/postcall_filters/extra_variables/llms — merged onto the existing strategy')
     .action(auditStrategies_1.auditUpdateCommand);
-program.addHelpText('after', `
-${chalk_1.default.bold('Examples:')}
-  ${chalk_1.default.cyan(`${name} register`)}   sign up and log in
-  ${chalk_1.default.cyan(`${name} login`)}      log into an existing account
-  ${chalk_1.default.cyan(`${name} accounts`)}   list saved logins (* = active)
-  ${chalk_1.default.cyan(`${name} accounts use <email>`)}  switch account
-  ${chalk_1.default.cyan(`${name} whoami`)}     see who you're logged in as
-  ${chalk_1.default.cyan(`${name} config`)}     show settings and session status
-  ${chalk_1.default.cyan(`${name} agents list`)}              list your agents in a table
-  ${chalk_1.default.cyan(`${name} agents list --json`)}       output raw JSON
-  ${chalk_1.default.cyan(`${name} agents update <agentId> --set '{"name":"New"}' --commit "rename"`)}
-  ${chalk_1.default.cyan(`${name} calls make --agent <id> --to <number> --test`)}  place a test call
+program.addHelpText('after', `
+${chalk_1.default.bold('Examples:')}
+  ${chalk_1.default.cyan(`${name} register`)}   sign up and log in
+  ${chalk_1.default.cyan(`${name} login`)}      log into an existing account
+  ${chalk_1.default.cyan(`${name} accounts`)}   list saved logins (* = active)
+  ${chalk_1.default.cyan(`${name} accounts use <email>`)}  switch account
+  ${chalk_1.default.cyan(`${name} whoami`)}     see who you're logged in as
+  ${chalk_1.default.cyan(`${name} config`)}     show settings and session status
+  ${chalk_1.default.cyan(`${name} agents list`)}              list your agents in a table
+  ${chalk_1.default.cyan(`${name} agents list --json`)}       output raw JSON
+  ${chalk_1.default.cyan(`${name} agents update <agentId> --set '{"name":"New"}' --commit "rename"`)}
+  ${chalk_1.default.cyan(`${name} calls make --agent <id> --to <number> --test`)}  place a test call
 `);
 // Bare invocation → show help instead of an error.
 if (process.argv.length <= 2) {

package/dist/lib/agentUpdate.js

@@ -33,7 +33,7 @@ exports.REPLACE_WHOLESALE_KEYS = new Set([
 /** String-array fields the web trims + drops empties on; we match that. */
 exports.STRING_ARRAY_KEYS = new Set([
     'end_call_msg', 'instructions', 'guardrails', 'rebuttals', 'silence_prompts',
-    'punctuations_to_remove',
+    'substrings_to_remove',
 ]);
 /**
  * Which live catalogue list governs which field.
@@ -125,10 +125,10 @@ function validateCallSettings(obj) {
             throw new Error('Invalid value for "noise_cancellation_strength": expected a number between 0.05 and 1');
         }
     }
-    if ('punctuations_to_remove' in obj) {
-        const punctuations = obj.punctuations_to_remove;
+    if ('substrings_to_remove' in obj) {
+        const punctuations = obj.substrings_to_remove;
         if (!Array.isArray(punctuations) || punctuations.some((v) => typeof v !== 'string')) {
-            throw new Error('Invalid value for "punctuations_to_remove": expected an array of strings');
+            throw new Error('Invalid value for "substrings_to_remove": expected an array of strings');
         }
     }
     if ('webhook_headers' in obj) {

package/dist/lib/api.js

@@ -99,7 +99,7 @@ class Api {
         return (await this.request(method, `/cli/workflows${path}`, body)).data;
     }
     listWorkflows(search) {
-        const q = new URLSearchParams({ limit: '100', type: 'normal' });
+        const q = new URLSearchParams({ limit: '100' });
         if (search)
             q.set('search', search);
         return this.workflow('GET', `?${q}`);
@@ -396,6 +396,32 @@ class Api {
     updateAuditStrategy(strategyId, body) {
         return this.request('PUT', `/cli/audit-strategies/${strategyId}`, body);
     }
+    // --- chat simulations -------------------------------------------------------
+    createChatTestCase(body) { return this.request('POST', '/cli/chat-simulations/test-cases', body); }
+    listChatTestCases(chatAgentId) {
+        return this.request('GET', `/cli/chat-simulations/test-cases${qs({ chat_agent_id: chatAgentId })}`);
+    }
+    updateChatTestCase(id, body) {
+        return this.request('PUT', `/cli/chat-simulations/test-cases/${id}`, body);
+    }
+    deleteChatTestCase(id) { return this.request('DELETE', `/cli/chat-simulations/test-cases/${id}`); }
+    runChatSimulation(body) { return this.request('POST', '/cli/chat-simulations/runs', body); }
+    listChatSimulationRuns(chatAgentId) {
+        return this.request('GET', `/cli/chat-simulations/runs${qs({ chat_agent_id: chatAgentId })}`);
+    }
+    chatSimulationResults(batchId) { return this.request('GET', `/cli/chat-simulations/runs/${batchId}`); }
+    // --- chat audit strategies (WhatsApp AI Auditor) ------------------------------
+    listChatAuditStrategies(agentId) {
+        return this.request('GET', `/cli/chat-audit-strategies${qs({ agentId })}`);
+    }
+    createChatAuditStrategy(body) { return this.request('POST', '/cli/chat-audit-strategies', body); }
+    updateChatAuditStrategy(strategyId, body) {
+        return this.request('PUT', `/cli/chat-audit-strategies/${strategyId}`, body);
+    }
+    deleteChatAuditStrategy(strategyId) {
+        return this.request('DELETE', `/cli/chat-audit-strategies/${strategyId}`);
+    }
+    createChatAuditBatch(body) { return this.request('POST', '/cli/chat-audit-strategies/batches', body); }
 }
 exports.Api = Api;
 /** Build a `?a=1&b=2` query string, skipping undefined/empty values. */

package/dist/lib/workflowEdit.js

@@ -15,9 +15,20 @@ exports.disconnect = disconnect;
  */
 const DEFAULT_HANDLE = 'out';
 const X_STEP = 320;
+// Mirrors ENTRY_TYPES / BRANCH_END_TYPES in the server's utils/workflowGraph.js.
+// Nothing may lead into an entry point, and nothing may follow a branch end
+// (resume included: it does not stop the run but does finish the branch).
+const ENTRY_TYPES = ['start', 'inbound'];
+const BRANCH_END_TYPES = ['end', 'cancel', 'resume'];
+// One per workflow. Start is seeded and so is never added.
+const SINGLETON_TYPES = ['start', 'inbound'];
+const stopsBecause = (type) => type === 'resume' ? 'the lead goes back to where they were' : 'a run stops there';
 // Mirrors NODE_META in the dashboard's WorkflowCanvas.jsx.
 const DEFAULT_NAMES = {
+    inbound: 'Inbound Call',
     end: 'End',
+    cancel: 'Cancel Workflow',
+    resume: 'Resume Where They Were',
     'send-call': 'Send Call',
     'wa-template': 'WhatsApp Template',
     'wa-message': 'WhatsApp Message',
@@ -68,7 +79,11 @@ const nodeOf = (g, id) => {
         throw new Error(`No node with id "${id}". Ids: ${g.nodes.map((n) => n.id).join(', ')}`);
     return node;
 };
-const handlesOf = (node) => node.type === 'conditions' ? (node.exits || []).map((e) => e.id) : [DEFAULT_HANDLE];
+const handlesOf = (node) => {
+    if (BRANCH_END_TYPES.includes(node.type))
+        return [];
+    return node.type === 'conditions' ? (node.exits || []).map((e) => e.id) : [DEFAULT_HANDLE];
+};
 exports.handlesOf = handlesOf;
 /** The handle to use when the caller named none: the only one, or an error listing the choices. */
 function resolveHandle(node, handle) {
@@ -94,9 +109,19 @@ function addNode(g, opts) {
     if (!exports.ADDABLE_TYPES.includes(opts.type)) {
         throw new Error(`--type must be one of: ${exports.ADDABLE_TYPES.join(', ')} (a workflow has exactly one start, which already exists)`);
     }
+    if (SINGLETON_TYPES.includes(opts.type) && g.nodes.some((n) => n.type === opts.type)) {
+        throw new Error(`A workflow can only have one ${DEFAULT_NAMES[opts.type]} node.`);
+    }
+    if (opts.type === 'resume' && !g.nodes.some((n) => n.type === 'inbound')) {
+        throw new Error('A resume node has nothing to resume: add an inbound node first.');
+    }
     const anchor = opts.after ? nodeOf(g, opts.after) : undefined;
-    if (anchor?.type === 'end')
-        throw new Error(`Nothing can follow "${anchor.id}": a run stops at an End node.`);
+    if (anchor && BRANCH_END_TYPES.includes(anchor.type)) {
+        throw new Error(`Nothing can follow "${anchor.id}": ${stopsBecause(anchor.type)}.`);
+    }
+    if (ENTRY_TYPES.includes(opts.type) && opts.after) {
+        throw new Error(`Nothing can lead into a ${DEFAULT_NAMES[opts.type]} node: a run begins there. Add it without --after.`);
+    }
     const afterHandle = anchor ? resolveHandle(anchor, opts.handle) : undefined;
     const id = `${opts.type}-${stamp()}`;
     const node = {
@@ -121,8 +146,8 @@ function addNode(g, opts) {
         const previous = edgeFrom(g, anchor.id, afterHandle)?.to;
         setEdge(g, anchor.id, afterHandle, id);
         if (previous) {
-            if (opts.type === 'end') {
-                note = ` "${previous}" is no longer connected (an End has nothing after it).`;
+            if (BRANCH_END_TYPES.includes(opts.type)) {
+                note = ` "${previous}" is no longer connected (${stopsBecause(opts.type)}).`;
             }
             else {
                 const exits = node.exits || [];
@@ -164,10 +189,12 @@ function removeNode(g, nodeId, reconnect = false) {
 function connect(g, from, to, handle) {
     const source = nodeOf(g, from);
     const target = nodeOf(g, to);
-    if (source.type === 'end')
-        throw new Error(`Nothing can follow "${from}": a run stops at an End node.`);
-    if (target.type === 'start')
-        throw new Error(`Nothing can lead into "${to}": a run begins at Start.`);
+    if (BRANCH_END_TYPES.includes(source.type)) {
+        throw new Error(`Nothing can follow "${from}": ${stopsBecause(source.type)}.`);
+    }
+    if (ENTRY_TYPES.includes(target.type)) {
+        throw new Error(`Nothing can lead into "${to}": a run begins there.`);
+    }
     const h = resolveHandle(source, handle);
     const replaced = edgeFrom(g, from, h)?.to;
     setEdge(g, from, h, to);

package/package.json

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