callkaro-cli-unofficial 0.9.5 → 0.10.1

package/dist/commands/chatAgents.js

@@ -44,16 +44,14 @@ exports.chatAgentsCreateCommand = chatAgentsCreateCommand;
 exports.chatAgentsUpdateCommand = chatAgentsUpdateCommand;
 exports.chatAgentsCreateVersionCommand = chatAgentsCreateVersionCommand;
 exports.chatAgentsPublishCommand = chatAgentsPublishCommand;
-exports.chatAgentsDiffCommand = chatAgentsDiffCommand;
+exports.chatAgentsCompareCommand = chatAgentsCompareCommand;
 exports.chatAgentsDeleteVersionCommand = chatAgentsDeleteVersionCommand;
 exports.chatAgentsImportVersionsCommand = chatAgentsImportVersionsCommand;
 exports.chatAgentsImportCommand = chatAgentsImportCommand;
 exports.chatAgentsCommitsCommand = chatAgentsCommitsCommand;
 exports.chatAgentsCommitCommand = chatAgentsCommitCommand;
 exports.chatAgentsRevertCommand = chatAgentsRevertCommand;
-const dashboardApi_1 = require("../lib/dashboardApi");
 const session_1 = require("../lib/session");
-const dashboardAuth_1 = require("../lib/dashboardAuth");
 const fs_1 = require("fs");
 const ui_1 = require("../lib/ui");
 const looseJson_1 = require("../lib/looseJson");
@@ -218,7 +216,6 @@ async function chatAgentsCreateCommand(json, opts) {
 async function chatAgentsUpdateCommand(agentId, opts) {
     const api = (0, session_1.requireApi)();
     try {
-        await (0, dashboardAuth_1.refreshModelCatalog)();
         const patch = await readChatAgentJson(opts.set, undefined, '--set object');
         const res = await api.updateChatAgent(agentId, (0, versions_1.firstVersion)(opts.versions), patch);
         if (opts.json)
@@ -261,20 +258,47 @@ async function chatAgentsPublishCommand(agentId, opts) {
     }
 }
 /** `cku chat-agents diff <chatAgentId> --versions vA,vB | --commits cA,cB` */
-async function chatAgentsDiffCommand(chatAgentId, opts) {
+const lineCount = (s) => (s ? s.split('\n').length : 0);
+/** `cku chat-agents compare <agentId> --a <id> --b <id> [--commits] [--field name]` — versions by default (official 5.4.8). */
+async function chatAgentsCompareCommand(agentId, opts) {
     try {
-        const pair = (s, flag) => {
-            const p = (s || '').split(',').map((x) => x.trim()).filter(Boolean);
-            if (p.length !== 2)
-                throw new Error(`${flag} needs exactly two ids, comma-separated.`);
-            return [p[0], p[1]];
-        };
-        if (!!opts.versions === !!opts.commits)
-            throw new Error('Pass exactly one of --versions <vA,vB> or --commits <cA,cB>.');
-        const res = opts.versions
-            ? await (0, dashboardApi_1.dashboardApi)().compareChatAgentVersions(pair(opts.versions, '--versions'))
-            : await (0, dashboardApi_1.dashboardApi)().compareChatAgentCommits(chatAgentId, ...pair(opts.commits, '--commits'));
-        console.log(JSON.stringify(res, null, 2));
+        if (!opts.a || !opts.b)
+            return (0, ui_1.handleError)(new Error('--a <id> and --b <id> are required (version ids, or commit ids with --commits)'));
+        const api = (0, session_1.requireApi)();
+        const res = opts.commits
+            ? await api.compareChatAgentCommits(agentId, opts.a, opts.b)
+            : await api.compareChatAgentVersions(agentId, [opts.a, opts.b]);
+        if ((0, ui_1.output)(res, opts, 'comparison'))
+            return;
+        const label = (s) => `${s.versionName || s.id} (${s.id})${s.agentMode ? ` [${s.agentMode}]` : ''}`;
+        (0, ui_1.info)(`A: ${label(res.left)}\nB: ${label(res.right)}\n`);
+        if (res.modeMismatch)
+            (0, ui_1.info)(`Different agent types (${res.modeMismatch.left} vs ${res.modeMismatch.right}): only fields both use are compared.\n`);
+        if (opts.field) {
+            const t = res.textFieldDiffs[opts.field];
+            const c = res.changedFields[opts.field];
+            if (!t && !c)
+                return (0, ui_1.handleError)(new Error(`"${opts.field}" did not change. Changed: ${Object.keys(res.changedFields).join(', ') || '(none)'}`));
+            const a = t ? t.left : JSON.stringify(c.left, null, 2);
+            const b = t ? t.right : JSON.stringify(c.right, null, 2);
+            return void console.log(`--- A\n${a}\n\n--- B\n${b}`);
+        }
+        const rows = [];
+        for (const f of Object.keys(res.changedFields)) {
+            const t = res.textFieldDiffs[f];
+            const l = res.listDiffs?.[f];
+            rows.push([f, t ? `text: ${lineCount(t.left)} → ${lineCount(t.right)} lines` : l ? `+${l.added.length} -${l.removed.length} ~${l.changed.length}` : 'value changed']);
+        }
+        if (res.nodeDiffs)
+            rows.push(['flowGraph nodes', `+${res.nodeDiffs.added.length} -${res.nodeDiffs.removed.length} ~${res.nodeDiffs.changed.length}`]);
+        if (!rows.length)
+            console.log('No differences.');
+        else {
+            (0, ui_1.table)(['FIELD', 'CHANGE'], rows);
+            (0, ui_1.info)(`\n${rows.length} difference(s). Use --field <name> to see one side by side, or --json for everything (incl. per-node and per-function diffs).`);
+        }
+        if (res.notComparable?.length)
+            (0, ui_1.info)(`Not comparable (not used by both agent types): ${res.notComparable.join(', ')}`);
     }
     catch (err) {
         (0, ui_1.handleError)(err);

package/dist/commands/chatAuditStrategies.js

@@ -7,8 +7,6 @@ exports.chatAuditCreateCommand = chatAuditCreateCommand;
 exports.chatAuditUpdateCommand = chatAuditUpdateCommand;
 exports.chatAuditDeleteCommand = chatAuditDeleteCommand;
 exports.chatAuditBatchCommand = chatAuditBatchCommand;
-exports.chatAuditReportsCommand = chatAuditReportsCommand;
-const dashboardApi_1 = require("../lib/dashboardApi");
 const session_1 = require("../lib/session");
 const ui_1 = require("../lib/ui");
 const setJson_1 = require("./setJson");
@@ -142,21 +140,3 @@ async function chatAuditBatchCommand(agentId, strategyId, opts) {
         (0, ui_1.handleError)(err);
     }
 }
-/** `cku chat-audit reports [--agent <id>] [--page <n>]` — dashboard session. */
-async function chatAuditReportsCommand(opts) {
-    try {
-        const res = await (0, dashboardApi_1.dashboardApi)().chatAuditReportBatches({
-            agentId: opts.agent,
-            page: opts.page ? Number(opts.page) : undefined,
-        });
-        if (opts.json)
-            return void console.log(JSON.stringify(res, null, 2));
-        const rows = res?.data?.batches || res?.batches || (Array.isArray(res?.data) ? res.data : []);
-        if (!rows.length)
-            return void (0, ui_1.info)('No chat audit report batches.');
-        (0, ui_1.table)(['ID', 'STATUS', 'CREATED'], rows.map((r) => [r._id || r.id || '', r.status || '', r.createdAt || '']));
-    }
-    catch (err) {
-        (0, ui_1.handleError)(err);
-    }
-}

package/dist/commands/contacts.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.collect = void 0;
 exports.contactsListCommand = contactsListCommand;
+exports.contactsMessagesCommand = contactsMessagesCommand;
 exports.contactsGetCommand = contactsGetCommand;
 exports.contactsCreateCommand = contactsCreateCommand;
 exports.contactsUpdateCommand = contactsUpdateCommand;
@@ -53,18 +54,6 @@ const attrValue = (c, name) => {
     const v = a && typeof a === 'object' && 'value' in a ? a.value : a;
     return v === undefined || v === null ? '' : typeof v === 'object' ? JSON.stringify(v) : String(v);
 };
-function output(value, opts, label) {
-    if (opts.file) {
-        (0, fs_1.writeFileSync)(opts.file, JSON.stringify(value, null, 2));
-        (0, ui_1.success)(`Saved ${label} to ${opts.file}`);
-        return true;
-    }
-    if (opts.json) {
-        console.log(JSON.stringify(value, null, 2));
-        return true;
-    }
-    return false;
-}
 // ---- contacts -------------------------------------------------------------
 async function contactsListCommand(opts) {
     const api = (0, session_1.requireApi)();
@@ -75,7 +64,7 @@ async function contactsListCommand(opts) {
             page: opts.page,
             pageSize: opts.pageSize,
         });
-        if (output({ contacts, pagination }, opts, 'contacts'))
+        if ((0, ui_1.output)({ contacts, pagination }, opts, 'contacts'))
             return;
         if (!contacts.length)
             return void (0, ui_1.info)('No contacts match.');
@@ -89,11 +78,39 @@ async function contactsListCommand(opts) {
         (0, ui_1.handleError)(err);
     }
 }
+/** `cku contacts messages <phone>` — a contact's chat messages, newest first (official 5.4.8). */
+async function contactsMessagesCommand(phone, opts) {
+    try {
+        const result = await (0, session_1.requireApi)().getContactMessages(phone.replace(/\D/g, ''), {
+            agentPhoneNumber: opts.agentPhoneNumber?.replace(/\D/g, ''),
+            channel: opts.channel,
+            threadId: opts.threadId,
+            page: opts.page,
+            pageSize: opts.pageSize,
+        });
+        if ((0, ui_1.output)(result, opts, 'contact messages'))
+            return;
+        if (!result.messages?.length)
+            return void (0, ui_1.info)('No messages found for this contact.');
+        (0, ui_1.table)(['TIME', 'DIRECTION', 'CHANNEL', 'MESSAGE', 'STATUS'], result.messages.map((m) => [
+            String(m.createdAt || '').slice(0, 19), // drop milliseconds
+            m.direction || '',
+            m.channel || '',
+            String(m.body || m.contentLink || m.template || '').replace(/\s+/g, ' ').slice(0, 100),
+            m.status || '',
+        ]));
+        const { page, totalPages, total, hasNext } = result.pagination || {};
+        (0, ui_1.info)(`Page ${page ?? 1}/${totalPages || 1} - ${total ?? result.messages.length} message(s)${hasNext ? '  (use --page to see more)' : ''}`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
 async function contactsGetCommand(phone, opts) {
     const api = (0, session_1.requireApi)();
     try {
         const { contact } = await api.getContact(phone);
-        if (output(contact, opts, 'contact'))
+        if ((0, ui_1.output)(contact, opts, 'contact'))
             return;
         (0, ui_1.keyValue)({
             Phone: contact.phone_number,
@@ -303,7 +320,7 @@ async function attributesListCommand(opts) {
     const api = (0, session_1.requireApi)();
     try {
         const { definitions } = await api.listContactAttributes();
-        if (output(definitions, opts, 'attributes'))
+        if ((0, ui_1.output)(definitions, opts, 'attributes'))
             return;
         if (!definitions.length) {
             return void (0, ui_1.info)('No attributes defined yet. Create one with `cku contacts attributes set <name>`.');

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);
+    }
+}