callkaro-cli-unofficial 0.9.4 → 0.10.0

package/README.md

@@ -200,8 +200,21 @@ npm run catalog:check    # fail if catalog.json disagrees with the snapshot
 
 `catalog:check` runs offline against a committed snapshot, so it works in CI with no credentials. On 1 October 2026 it caught shipped tables that listed withdrawn models *and* missed live ones in both directions. A wrong voice model otherwise persists silently and only surfaces as a broken call.
 
+### Live test calls, with you or an LLM as the caller
+
+```bash
+cku test start <agentId> --yes          # a coding agent (or you) plays the caller, one turn per command
+cku test say <sessionId> "Kitne ka hai?"
+cku test end <sessionId>                # transcript with function calls and node switches
+
+cku test run <agentId> --test <testCaseId> --llm anthropic --yes   # the CLI plays the caller and grades the call
+```
+
+This is the agent editor's **Test Chat** tab from a terminal: a real test call on the real call runtime, over the same LiveKit room the dashboard joins, with the caller typing instead of speaking. Unlike a simulation, nothing is mocked, so node switching, function calls and post-call analysis are what production does, and every function runs for real. `run` uses any OpenAI-compatible LLM (OpenAI, Anthropic, Gemini, DeepSeek, Groq, OpenRouter, Ollama, or `--llm-url`), with the key read from the environment, and exits 1 when the judge fails the call. It needs `@livekit/rtc-node`, an optional dependency with prebuilt binaries for Linux, macOS and Windows.
+
 ### Smaller things
 
+- `cku sim create --real-functions` — every function on the version runs for real in the simulation, like switching every Mock off in the dashboard
 - `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

package/dist/commands/agentMemory.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentsMemoryCommand = agentsMemoryCommand;
+exports.agentsVoiceRotationCommand = agentsVoiceRotationCommand;
+const fs_1 = require("fs");
+const session_1 = require("../lib/session");
+const ui_1 = require("../lib/ui");
+const versions_1 = require("../lib/versions");
+const looseJson_1 = require("../lib/looseJson");
+const liveVoiceCheck_1 = require("../lib/liveVoiceCheck");
+const agentMemory_1 = require("../lib/agentMemory");
+async function run(agentId, opts, flags, change, describe, what, verify) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const versionId = (0, versions_1.firstVersion)(opts.versions);
+        if (!versionId)
+            throw new Error('--versions <id> is required (find it with `cku agents versions <agentId>`)');
+        const { agent } = await api.getAgent(agentId, versionId);
+        const current = agent.agentMemory;
+        if (!(0, agentMemory_1.hasChanges)(flags)) {
+            if (opts.json)
+                console.log(JSON.stringify(current ?? {}, null, 2));
+            else
+                (0, ui_1.keyValue)(describe(current));
+            return;
+        }
+        const next = change(current);
+        if (verify)
+            await verify(api, next, agent);
+        const body = { agentMemory: next };
+        if (opts.commit)
+            body.commitMessage = opts.commit;
+        const result = await api.updateAgent(agentId, versionId, body);
+        if (opts.json)
+            console.log(JSON.stringify(next, null, 2));
+        else {
+            (0, ui_1.success)(result.msg || `${what} updated.`);
+            (0, ui_1.keyValue)(describe(next));
+            (0, ui_1.info)('  Takes effect on the next call. Publish the version if it is not live yet.');
+        }
+    }
+    catch (error) {
+        (0, ui_1.handleError)(error);
+    }
+}
+function agentsMemoryCommand(agentId, opts) {
+    const { versions, commit, json, ...flags } = opts;
+    return run(agentId, opts, flags, (memory) => (0, agentMemory_1.applyMemoryFlags)(memory, flags), agentMemory_1.describeMemory, 'Call memory');
+}
+function agentsVoiceRotationCommand(agentId, opts) {
+    const { versions, commit, json, voices, ...rest } = opts;
+    const flags = rest;
+    if (voices !== undefined) {
+        const file = String(voices).startsWith('@') ? String(voices).slice(1) : String(voices);
+        if (!(0, fs_1.existsSync)(file)) {
+            (0, ui_1.handleError)(new Error(`File not found: ${file}`));
+            return Promise.resolve();
+        }
+        try {
+            flags.voices = JSON.parse((0, looseJson_1.readJsonFile)(file));
+        }
+        catch (error) {
+            (0, ui_1.handleError)(new Error(`--voices is not valid JSON: ${error.message}`));
+            return Promise.resolve();
+        }
+    }
+    const verify = flags.voices === undefined ? undefined : async (api, memory, version) => {
+        const entries = Object.fromEntries((memory.voice_rotation_config?.voices || []).map((voice, index) => [`voices[${index}]`, voice]));
+        await (0, liveVoiceCheck_1.checkVoiceConfigs)(api, entries, async () => (0, liveVoiceCheck_1.savedVoices)(version));
+    };
+    return run(agentId, opts, flags, (memory) => (0, agentMemory_1.applyRotationFlags)(memory, flags), agentMemory_1.describeRotation, 'Voice rotation', verify);
+}

package/dist/commands/agentVersions.js

@@ -19,6 +19,7 @@ const dashboardApi_1 = require("../lib/dashboardApi");
 const ui_1 = require("../lib/ui");
 const versions_1 = require("../lib/versions");
 const agentUpdate_1 = require("../lib/agentUpdate");
+const liveVoiceCheck_1 = require("../lib/liveVoiceCheck");
 const setJson_1 = require("./setJson");
 /** Keys a clone may override. Anything else is rejected before the request. */
 const CLONE_OVERRIDE_KEYS = new Set([
@@ -60,7 +61,8 @@ async function agentsCloneVersionCommand(agentId, opts) {
             if (unsupported.length) {
                 return (0, ui_1.handleError)(new Error(`Unsupported clone override(s): ${unsupported.join(', ')}\n  allowed: ${[...CLONE_OVERRIDE_KEYS].join(', ')}`));
             }
-            overrides = (0, agentUpdate_1.preparePatch)(parsed).patch;
+            overrides = (0, agentUpdate_1.preparePatch)(parsed, { skipVoices: true }).patch;
+            await (0, liveVoiceCheck_1.checkVoiceConfigs)(api, { voice_configuration: overrides.voice_configuration, secondary_voice_configuration: overrides.secondary_voice_configuration }, sourceVersionId ? async () => (0, liveVoiceCheck_1.savedVoices)((await api.getAgent(agentId, sourceVersionId)).agent) : undefined);
         }
         const res = await api.cloneAgentVersion(agentId, sourceVersionId, {
             ...overrides,

package/dist/commands/agents.js

@@ -53,6 +53,7 @@ const ui_1 = require("../lib/ui");
 const versions_1 = require("../lib/versions");
 const agentUpdate_1 = require("../lib/agentUpdate");
 Object.defineProperty(exports, "preparePatch", { enumerable: true, get: function () { return agentUpdate_1.preparePatch; } });
+const liveVoiceCheck_1 = require("../lib/liveVoiceCheck");
 const dashboardAuth_1 = require("../lib/dashboardAuth");
 const agentImport_1 = require("../lib/agentImport");
 const dbFields_1 = require("../lib/dbFields");
@@ -400,7 +401,7 @@ async function agentsUpdateCommand(agentId, opts) {
         const dbf = (0, dbFields_1.dbManagedFields)(obj);
         if (dbf.length)
             throw new Error((0, dbFields_1.dbManagedFieldsError)(dbf, '--set object'));
-        const prepared = (0, agentUpdate_1.preparePatch)(obj); // throws on invalid enum/model values
+        const prepared = (0, agentUpdate_1.preparePatch)(obj, { skipVoices: true });
         patch = prepared.patch;
         versionKeys = prepared.versionKeys;
         wholesaleKeys = prepared.wholesaleKeys;
@@ -421,37 +422,60 @@ async function agentsUpdateCommand(agentId, opts) {
             '  Run the command once per version id.'));
     }
     try {
-        // The backend replaces these objects wholesale, so a partial --set would drop
-        // every sibling key. Merge against the agent's current value first. This is
-        // a no-op when the object sent is already complete. Merge against the
-        // *target* version: without one, getAgent returns the default version, and
-        // its siblings (provider, voice id, …) would be written onto a different
-        // version. Wholesale keys are version-level, so --versions is set here.
-        // `functions` is a whole array on the backend: merge by name unless the
-        // caller asked to replace the list.
+        const vid = (0, versions_1.firstVersion)(opts.versions);
+        await (0, liveVoiceCheck_1.checkVoiceConfigs)(api, { voice_configuration: patch.voice_configuration, secondary_voice_configuration: patch.secondary_voice_configuration }, vid ? async () => (0, liveVoiceCheck_1.savedVoices)((await api.getAgent(agentId, vid)).agent) : undefined);
+        let versionTarget = vid;
+        if (opts.commit && !versionTarget)
+            versionTarget = (await api.getAgent(agentId)).agent.versionId;
         const mergeFns = Array.isArray(patch.functions) && !opts.replaceFunctions;
-        if (wholesaleKeys.length || mergeFns) {
-            const { agent } = await api.getAgent(agentId, (0, versions_1.firstVersion)(opts.versions));
-            patch = (0, agentUpdate_1.mergeWholesaleKeys)(patch, agent);
+        let current;
+        try {
+            current = (await api.getAgent(agentId, versionTarget)).agent;
+        }
+        catch (error) {
+            if (mergeFns)
+                throw error;
+            (0, ui_1.info)('  (could not read the current values; sending the patch as given)');
+        }
+        let effectivePatch = patch;
+        if (current) {
+            if (wholesaleKeys.length)
+                effectivePatch = (0, agentUpdate_1.mergeWholesaleKeys)(effectivePatch, current);
             if (mergeFns)
-                patch.functions = (0, agentUpdate_1.mergeFunctions)(patch.functions, agent.functions);
+                effectivePatch.functions = (0, agentUpdate_1.mergeFunctions)(effectivePatch.functions, current.functions);
+        }
+        let { send, changed, unchanged } = current
+            ? (0, agentUpdate_1.planUpdate)(current, effectivePatch)
+            : { send: effectivePatch, changed: Object.keys(effectivePatch), unchanged: [] };
+        if (opts.dryRun) {
+            if (opts.json)
+                console.log(JSON.stringify({ dryRun: true, changing: changed, unchanged }, null, 2));
+            else {
+                (0, ui_1.info)(`  would change: ${changed.join(', ') || '(nothing)'}`);
+                if (unchanged.length)
+                    (0, ui_1.info)(`  already set, skipped: ${unchanged.join(', ')}`);
+                (0, ui_1.info)('  Nothing saved (--dry-run).');
+            }
+            return;
+        }
+        if (!changed.length) {
+            (0, ui_1.info)(`Nothing to change: ${unchanged.join(', ')} already hold the requested value(s).`);
+            return;
         }
-        // A commit message is recorded against a version. Version-level updates
-        // already name one; for an agent-level-only update with --commit, attach it
-        // to the agent's current version so the change (e.g. a rename) is logged.
-        let versionTarget = (0, versions_1.firstVersion)(opts.versions);
-        if (opts.commit && !versionTarget) {
-            const { agent } = await api.getAgent(agentId);
-            versionTarget = agent.versionId;
+        if (changed.length > agentUpdate_1.MAX_FIELDS_WITHOUT_YES && !opts.yes) {
+            return (0, ui_1.handleError)(new Error(`This would change ${changed.length} fields (${changed.join(', ')}).\n` +
+                '  Send only the fields you mean to change. If this is intended, re-run with --yes (or preview with --dry-run).'));
         }
-        const body = { ...patch };
+        const body = { ...send };
         if (opts.commit)
             body.commitMessage = opts.commit;
         const res = await api.updateAgent(agentId, versionTarget, body);
         if (opts.json)
             return void console.log(JSON.stringify(res, null, 2));
         (0, ui_1.success)(res.msg || 'Agent updated.');
-        (0, ui_1.info)(`  updated: ${Object.keys(patch).join(', ')}`);
+        (0, ui_1.info)(`  updated: ${changed.join(', ')}`);
+        if (unchanged.length)
+            (0, ui_1.info)(`  already set, skipped: ${unchanged.join(', ')}`);
         if (opts.commit)
             (0, ui_1.info)(`  commit:  ${opts.commit}`);
     }

package/dist/commands/liveTest.js

@@ -0,0 +1,330 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testStartCommand = testStartCommand;
+exports.testSayCommand = testSayCommand;
+exports.testEndCommand = testEndCommand;
+exports.testServeCommand = testServeCommand;
+exports.testRunCommand = testRunCommand;
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const http_1 = require("http");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const chalk_1 = __importDefault(require("chalk"));
+const session_1 = require("../lib/session");
+const config_1 = require("../lib/config");
+const ui_1 = require("../lib/ui");
+const versions_1 = require("../lib/versions");
+const liveTest_1 = require("../lib/liveTest");
+const jsonInput_1 = require("./jsonInput");
+/**
+ * `cku test`: live test calls over the dashboard's Test Chat path (lib/liveTest.ts).
+ *
+ * Two ways to play the caller:
+ *  - start / say / end: a coding agent (or a person) plays the caller one turn per command.
+ *    A detached background process holds the LiveKit room between commands and serves them on
+ *    127.0.0.1, guarded by a per-session secret.
+ *  - run: the CLI plays the caller with an LLM and grades the call against criteria.
+ */
+const SESSIONS_DIR = (0, path_1.join)(config_1.CONFIG_DIR, 'test-sessions');
+const IDLE_MS = 10 * 60_000;
+const WARNING = 'This places a real test call: every agent function runs for real (CRM writes, WhatsApp, webhooks), '
+    + 'credits are used, and the call appears in call history with post-call analysis.';
+const sessionPath = (id) => (0, path_1.join)(SESSIONS_DIR, `${id}.json`);
+function printEvents(events) {
+    for (const e of events) {
+        if (e.type === 'agent')
+            (0, ui_1.info)(`${chalk_1.default.cyan('agent>')} ${e.text}`);
+        else if (e.type === 'user')
+            (0, ui_1.info)(`${chalk_1.default.green('caller>')} ${e.text}`);
+        else if (e.type === 'function')
+            (0, ui_1.info)(chalk_1.default.dim(`  → ${e.name} ${JSON.stringify(e.arguments ?? {})}`));
+        else if (e.type === 'capability')
+            (0, ui_1.info)(chalk_1.default.dim(`  [node: ${e.capability}]`));
+        else if (e.type === 'ended')
+            (0, ui_1.info)(chalk_1.default.dim('  (call ended)'));
+    }
+}
+async function readMetadata(opts) {
+    if (!opts.variables)
+        return {};
+    const v = await (0, jsonInput_1.readJsonFlag)(opts.variables, '--variables');
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        throw new Error('--variables must be a JSON object, e.g. {"customer_name":"Ravi"}');
+    return v;
+}
+/** The test call is created under the agent's owner, which is also what the dashboard sends. */
+async function startToken(agentId, version, metadata) {
+    const res = await (0, session_1.requireApi)().getAgent(agentId, version);
+    const agent = res.agent || res;
+    const userId = agent?.userId;
+    if (!userId)
+        throw new Error(`Agent ${agentId} came back without a userId, so the test-call host cannot be chosen.`);
+    return (0, liveTest_1.requestTestToken)({ userId: String(userId), agentId, version, metadata });
+}
+// --- start / say / end ----------------------------------------------------------------------
+async function testStartCommand(agentId, opts) {
+    try {
+        if (!(await (0, ui_1.confirm)(`${WARNING} Start it?`, opts.yes)))
+            return;
+        const version = (0, versions_1.firstVersion)(opts.versions);
+        const { token, callSid } = await startToken(agentId, version, await readMetadata(opts));
+        (0, fs_1.mkdirSync)(SESSIONS_DIR, { recursive: true, mode: 0o700 });
+        const id = (0, crypto_1.randomBytes)(4).toString('hex');
+        (0, fs_1.writeFileSync)((0, path_1.join)(SESSIONS_DIR, `${id}.req.json`), JSON.stringify({ token, callSid, agentId }), { mode: 0o600 });
+        (0, child_process_1.spawn)(process.execPath, [process.argv[1], 'test', '_serve', id], {
+            detached: true, stdio: 'ignore', windowsHide: true, env: { ...process.env, CK_NO_UPDATE_CHECK: '1' },
+        }).unref();
+        const deadline = Date.now() + 60_000;
+        while (!(0, fs_1.existsSync)(sessionPath(id))) {
+            if (Date.now() > deadline)
+                throw new Error('The test session did not come up within 60s. If the call started, find it with: cku calls list --sid ${callSid}');
+            await new Promise((r) => setTimeout(r, 250));
+        }
+        const s = JSON.parse((0, fs_1.readFileSync)(sessionPath(id), 'utf8'));
+        if (s.error) {
+            (0, fs_1.unlinkSync)(sessionPath(id));
+            throw new Error(s.error);
+        }
+        if (opts.json)
+            return void console.log(JSON.stringify({ sessionId: id, callSid, events: s.greeting }, null, 2));
+        (0, ui_1.info)(chalk_1.default.dim(`session ${id}  call ${callSid}`));
+        if (s.greeting.length)
+            printEvents(s.greeting);
+        else
+            (0, ui_1.info)(chalk_1.default.dim('(the agent is waiting for the caller to speak first)'));
+        (0, ui_1.info)(chalk_1.default.dim(`Next: cku test say ${id} "<what the caller says>"   ·   cku test end ${id}`));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function callSession(id, path, body) {
+    if (!/^[0-9a-f]{8}$/.test(id) || !(0, fs_1.existsSync)(sessionPath(id))) {
+        throw new Error(`No test session "${id}". Start one with: cku test start <agentId>`);
+    }
+    const s = JSON.parse((0, fs_1.readFileSync)(sessionPath(id), 'utf8'));
+    try {
+        const res = await fetch(`http://127.0.0.1:${s.port}${path}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'x-session-secret': s.secret },
+            body: JSON.stringify(body),
+        });
+        const data = await res.json();
+        if (!res.ok)
+            throw new Error(data.error || `Session answered HTTP ${res.status}`);
+        return data;
+    }
+    catch (err) {
+        if (err?.cause?.code === 'ECONNREFUSED') {
+            try {
+                (0, fs_1.unlinkSync)(sessionPath(id));
+            }
+            catch { /* gone */ }
+            throw new Error(`Test session ${id} is no longer running (it ends after 10 idle minutes). Find the call with: cku calls list --sid ${s.callSid}`);
+        }
+        throw err;
+    }
+}
+async function testSayCommand(id, words, opts) {
+    try {
+        const text = words.join(' ').trim();
+        if (!text)
+            throw new Error('Nothing to say. Usage: cku test say <sessionId> "<what the caller says>"');
+        const timeoutMs = (0, ui_1.intFlag)(opts.timeout, '--timeout', 60) * 1000;
+        const data = await callSession(id, '/say', { text, timeoutMs });
+        if (opts.json)
+            return void console.log(JSON.stringify(data, null, 2));
+        printEvents(data.events.filter((e) => e.type !== 'user'));
+        if (!data.events.some((e) => e.type === 'agent') && !data.ended)
+            (0, ui_1.info)(chalk_1.default.dim('(no agent reply before the timeout)'));
+        if (data.ended)
+            (0, ui_1.info)(chalk_1.default.dim(`The call is over. Collect it with: cku test end ${id}`));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function testEndCommand(id, opts) {
+    try {
+        const data = await callSession(id, '/end', {});
+        if (opts.json)
+            return void console.log(JSON.stringify(data, null, 2));
+        (0, ui_1.info)((0, liveTest_1.formatTranscript)(data.events));
+        (0, ui_1.info)(chalk_1.default.dim(`call ${data.callSid}: post-call results: cku calls list --sid ${data.callSid}`));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** The background half of `start`: owns the room, answers say/end on localhost, exits when done or idle. */
+async function testServeCommand(id) {
+    const reqPath = (0, path_1.join)(SESSIONS_DIR, `${id}.req.json`);
+    const { token, callSid, agentId } = JSON.parse((0, fs_1.readFileSync)(reqPath, 'utf8'));
+    (0, fs_1.unlinkSync)(reqPath);
+    const write = (s) => (0, fs_1.writeFileSync)(sessionPath(id), JSON.stringify(s), { mode: 0o600 });
+    let session;
+    let greeting;
+    try {
+        ({ session, greeting } = await liveTest_1.LiveSession.open(token, callSid));
+    }
+    catch (err) {
+        write({ error: `Could not join the test call room: ${err.message}` });
+        return;
+    }
+    const secret = (0, crypto_1.randomBytes)(16).toString('hex');
+    let idle;
+    let busy = false;
+    const shutdown = async () => {
+        server.close();
+        try {
+            (0, fs_1.unlinkSync)(sessionPath(id));
+        }
+        catch { /* gone */ }
+        await session.close();
+        process.exit(0);
+    };
+    const touch = () => { clearTimeout(idle); idle = setTimeout(shutdown, IDLE_MS); };
+    const server = (0, http_1.createServer)((req, res) => {
+        const reply = (status, body) => { res.writeHead(status, { 'Content-Type': 'application/json' }); res.end(JSON.stringify(body)); };
+        if (req.headers['x-session-secret'] !== secret || req.method !== 'POST')
+            return reply(403, { error: 'forbidden' });
+        let raw = '';
+        req.on('data', (c) => { raw += c; if (raw.length > 100_000)
+            req.destroy(); });
+        req.on('end', async () => {
+            touch();
+            try {
+                const body = raw ? JSON.parse(raw) : {};
+                if (req.url === '/say') {
+                    if (busy)
+                        return reply(409, { error: 'The agent is still answering the previous turn. Wait for that command to finish.' });
+                    busy = true;
+                    try {
+                        const events = await session.say(String(body.text || ''), Number(body.timeoutMs) || 60_000);
+                        return reply(200, { sessionId: id, callSid, events, ended: session.ended });
+                    }
+                    finally {
+                        busy = false;
+                    }
+                }
+                if (req.url === '/end') {
+                    reply(200, { sessionId: id, callSid, agentId, events: session.events, ended: session.ended });
+                    return void setTimeout(shutdown, 100);
+                }
+                reply(404, { error: 'unknown route' });
+            }
+            catch (err) {
+                reply(500, { error: err.message });
+            }
+        });
+    });
+    server.listen(0, '127.0.0.1', () => {
+        const port = server.address().port;
+        write({ pid: process.pid, port, secret, callSid, agentId, greeting });
+        touch();
+    });
+}
+async function scenario(agentId, opts) {
+    let s = { name: '', persona: opts.persona, prompt: opts.prompt, criteria: opts.criteria, variables: {} };
+    if (opts.test) {
+        const res = await (0, session_1.requireApi)().listTestCases(agentId);
+        const t = (res.testCases || res.data || []).find((x) => x._id === opts.test);
+        if (!t)
+            throw new Error(`Test case ${opts.test} is not one of this agent's. List them with: cku sim tests ${agentId}`);
+        s = { name: t.testcaseName || '', persona: t.userPersona, prompt: t.userPrompt, criteria: t.successCriteria, variables: t.testVariables || {} };
+        if (opts.persona)
+            s.persona = opts.persona;
+        if (opts.prompt)
+            s.prompt = opts.prompt;
+        if (opts.criteria)
+            s.criteria = opts.criteria;
+    }
+    s.variables = { ...s.variables, ...(await readMetadata(opts)) };
+    if (!s.prompt)
+        throw new Error('Say what the caller wants: --prompt "<goal and beats>" (or --test <testCaseId> to reuse a saved simulation test case).');
+    return { ...s, prompt: s.prompt };
+}
+async function testRunCommand(agentId, opts) {
+    let session;
+    try {
+        const s = await scenario(agentId, opts);
+        const llm = (0, liveTest_1.resolveLlm)(opts);
+        const judge = { ...llm, model: opts.judgeModel || llm.model };
+        const maxTurns = (0, ui_1.intFlag)(opts.maxTurns, '--max-turns', 20);
+        const turnMs = (0, ui_1.intFlag)(opts.timeout, '--timeout', 60) * 1000;
+        if (!(await (0, ui_1.confirm)(`${WARNING} Run it?`, opts.yes)))
+            return;
+        const log = (events) => { if (!opts.json)
+            printEvents(events); };
+        const { token, callSid } = await startToken(agentId, (0, versions_1.firstVersion)(opts.versions), s.variables);
+        if (!opts.json)
+            (0, ui_1.info)(chalk_1.default.dim(`call ${callSid}  caller: ${llm.name}/${llm.model}`));
+        const opened = await liveTest_1.LiveSession.open(token, callSid);
+        session = opened.session;
+        log(opened.greeting);
+        const history = [{ role: 'system', content: (0, liveTest_1.callerSystemPrompt)(s) }];
+        const agentSaid = (events) => events.filter((e) => e.type === 'agent').map((e) => e.text).join(' ');
+        let heard = agentSaid(opened.greeting);
+        let endedBy = 'max-turns';
+        for (let turn = 0; turn < maxTurns; turn++) {
+            if (session.ended) {
+                endedBy = 'agent';
+                break;
+            }
+            history.push({ role: 'user', content: heard || '(The call is connected. The agent has not said anything yet.)' });
+            const line = (0, liveTest_1.parseCallerLine)(await (0, liveTest_1.chatComplete)(llm, history));
+            history.push({ role: 'assistant', content: line.text || '(hangs up)' });
+            if (line.text) {
+                if (session.ended) {
+                    endedBy = 'agent';
+                    break;
+                }
+                const events = await session.say(line.text, turnMs);
+                log([{ type: 'user', text: line.text, t: Date.now() }, ...events]);
+                heard = agentSaid(events);
+                if (session.ended) {
+                    endedBy = 'agent';
+                    break;
+                }
+                if (!events.length) {
+                    endedBy = 'timeout';
+                    break;
+                }
+            }
+            if (line.end) {
+                endedBy = 'caller';
+                break;
+            }
+        }
+        const events = session.events;
+        await session.close();
+        session = undefined;
+        let verdict;
+        if (s.criteria)
+            verdict = (0, liveTest_1.parseVerdict)(await (0, liveTest_1.chatComplete)(judge, (0, liveTest_1.judgeMessages)(s.criteria, events), 0));
+        const out = { callSid, agentId, test: opts.test, endedBy, caller: `${llm.name}/${llm.model}`, events, verdict };
+        if (opts.json)
+            console.log(JSON.stringify(out, null, 2));
+        else {
+            (0, ui_1.info)(chalk_1.default.dim(`ended by: ${endedBy}`));
+            if (verdict) {
+                const label = verdict.invalid ? chalk_1.default.yellow('GRADING FAILED') : verdict.pass ? chalk_1.default.green('PASS') : chalk_1.default.red('FAIL');
+                (0, ui_1.info)(`${label}  ${verdict.summary}`);
+                for (const c of verdict.criteria)
+                    (0, ui_1.info)(`  ${c.pass ? chalk_1.default.green('✔') : chalk_1.default.red('✖')} ${c.criterion}${c.evidence ? chalk_1.default.dim(` (${c.evidence})`) : ''}${c.reason && !c.pass ? ` — ${c.reason}` : ''}`);
+            }
+            (0, ui_1.info)(chalk_1.default.dim(`post-call results: cku calls list --sid ${callSid}`));
+        }
+        if (verdict && !verdict.pass)
+            process.exitCode = 1;
+    }
+    catch (err) {
+        if (session)
+            await session.close();
+        (0, ui_1.handleError)(err);
+    }
+}

package/dist/commands/simulations.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.sleep = void 0;
 exports.toTestVariables = toTestVariables;
 exports.toTestFunctions = toTestFunctions;
+exports.realFunctionList = realFunctionList;
 exports.simTestsListCommand = simTestsListCommand;
 exports.simCreateCommand = simCreateCommand;
 exports.simUpdateCommand = simUpdateCommand;
@@ -58,6 +59,21 @@ function toTestFunctions(input) {
         return { name: f.name, ...(f.mock === undefined ? {} : { mock: f.mock }), ...('response' in f ? { response: f.response } : {}) };
     });
 }
+/**
+ * `--real-functions`: every function on the agent version (version-level + node/capability), as
+ * `{name, mock:false}`, the CLI twin of switching every Mock toggle off in the dashboard. Entries
+ * from `--functions` win by name. WhatsApp functions stay out (they must never run for real).
+ */
+function realFunctionList(version, explicit = []) {
+    const all = [...(version.functions || []), ...(version.capabilities || []).flatMap((c) => c.functions || [])];
+    const names = [...new Set(all.filter((f) => f?.name && !/whatsapp/i.test(String(f.type || ''))).map((f) => f.name))];
+    const byName = new Map(explicit.map((f) => [f.name, f]));
+    return [...names.map((n) => byName.get(n) || { name: n, mock: false }), ...explicit.filter((f) => !names.includes(f.name))];
+}
+async function withRealFunctions(api, agentId, version, explicit) {
+    const res = await api.getAgent(agentId, version);
+    return realFunctionList(res.agent || res, explicit);
+}
 async function simTestsListCommand(agentId, opts) {
     const api = (0, session_1.requireApi)();
     try {
@@ -78,7 +94,9 @@ async function simCreateCommand(agentId, opts) {
     try {
         // Parse the JSON flags before prompting, so a typo fails before any typing.
         const testVariables = opts.variables ? toTestVariables(await (0, jsonInput_1.readJsonFlag)(opts.variables, '--variables')) : {};
-        const testFunctions = opts.functions ? toTestFunctions(await (0, jsonInput_1.readJsonFlag)(opts.functions, '--functions')) : [];
+        let testFunctions = opts.functions ? toTestFunctions(await (0, jsonInput_1.readJsonFlag)(opts.functions, '--functions')) : [];
+        if (opts.realFunctions)
+            testFunctions = await withRealFunctions(api, agentId, opts.versions, testFunctions);
         let { name, persona, prompt, criteria } = opts;
         if (!name || !prompt || !criteria) {
             (0, ui_1.needTty)('Pass --name, --prompt and --criteria.');
@@ -143,8 +161,13 @@ async function simUpdateCommand(testCaseId, opts) {
             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 (opts.realFunctions) {
+            if (!opts.agent)
+                return (0, ui_1.handleError)(new Error('--real-functions on update needs --agent <agentId> (the test case does not carry it).'));
+            body.testFunctions = await withRealFunctions(api, opts.agent, opts.versions, body.testFunctions || []);
+        }
         if (!Object.keys(body).length) {
-            return (0, ui_1.handleError)(new Error('Nothing to update. Pass at least one of --name, --persona, --prompt, --criteria, --model, --variables, --functions.'));
+            return (0, ui_1.handleError)(new Error('Nothing to update. Pass at least one of --name, --persona, --prompt, --criteria, --model, --variables, --functions, --real-functions.'));
         }
         const res = await api.updateTestCase(testCaseId, body);
         (0, ui_1.success)(`Updated test case ${res.testCase?._id || testCaseId}: ${Object.keys(body).join(', ')}.`);