callkaro-cli-unofficial 0.9.4 → 0.10.0

package/dist/lib/liveTest.js

@@ -0,0 +1,361 @@
+"use strict";
+/**
+ * Live test calls: the agent editor's "Test Chat" tab, from a terminal.
+ *
+ * Read out of the dashboard bundle (no upstream CLI has this):
+ *  1. POST {base}/outbound_call?is_test=true&chat=true[&version=] with {userId, agent_id, metadata}
+ *     returns {token, call_sid}. The request carries no credential: the server only checks that
+ *     `Origin` is the dashboard's (403 "Caller not allowed" otherwise), so it is sent here too.
+ *  2. Join the LiveKit room at wss://livekit-inbound.callkaro.ai with that token.
+ *  3. User turns go out as text on topic `lk.chat`. Agent text comes back as `lk.transcription`
+ *     text streams (LiveKit Agents 1.x), function calls as data packets on `lk.history`, the
+ *     active node as the agent participant's `current_capability` attribute, and the agent's
+ *     turn state as `lk.agent.state`. `lk.history` also carries a `{type:"message"}` item per
+ *     finished message, which is what marks an agent turn complete: seen live, `lk.agent.state`
+ *     returns to `listening` up to 1.2s before the transcript of that turn arrives.
+ *
+ * This is the real call runtime, not a simulation: every function runs for real and the call
+ * lands in call history with post-call analysis.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.END_MARK = exports.LLM_PRESETS = exports.LiveSession = exports.deps = exports.TEST_IDENTITY = exports.LIVEKIT_URL = void 0;
+exports.testCallBase = testCallBase;
+exports.requestTestToken = requestTestToken;
+exports.formatTranscript = formatTranscript;
+exports.resolveLlm = resolveLlm;
+exports.chatComplete = chatComplete;
+exports.callerSystemPrompt = callerSystemPrompt;
+exports.parseCallerLine = parseCallerLine;
+exports.judgeMessages = judgeMessages;
+exports.parseVerdict = parseVerdict;
+const fs_1 = require("fs");
+const config_1 = require("./config");
+exports.LIVEKIT_URL = 'wss://livekit-inbound.callkaro.ai';
+exports.TEST_IDENTITY = 'test_participant';
+// ponytail: copied from the dashboard bundle's host picker; re-read the bundle if a Spinny
+// account's test call 404s. CK_TEST_CALL_URL overrides the host for every account.
+const SPINNY_USER_IDS = new Set([
+    '681b6d70d73a629e2f9f9b5b', '683761f141599a2ac50570c7', '684980f1ad348c30b0155cc3',
+    '686eb5e262c7062950b41a23', '686eb58c62c7062950b41a20', '68e4e4da4a8835a2360e8aa6',
+    '6915a152a205df5fd2b576d7', '691c3d20409942e2d0492f76', '698dfcedbbb4b9d3496cb860',
+    '6a06f48caabb1c14cb9311b4',
+]);
+function testCallBase(userId) {
+    if (process.env.CK_TEST_CALL_URL)
+        return process.env.CK_TEST_CALL_URL.replace(/\/+$/, '');
+    return SPINNY_USER_IDS.has(userId) ? 'https://spinny.callkaro.ai' : 'https://api.callkaro.ai';
+}
+async function requestTestToken(input) {
+    let url = `${testCallBase(input.userId)}/outbound_call?is_test=true&chat=true`;
+    if (input.version)
+        url += `&version=${encodeURIComponent(input.version)}`;
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Origin: (0, config_1.webUrl)(), Referer: `${(0, config_1.webUrl)()}/` },
+        body: JSON.stringify({ userId: input.userId, agent_id: input.agentId, metadata: input.metadata || {} }),
+        signal: AbortSignal.timeout(30_000),
+    });
+    const body = await res.text();
+    let data = {};
+    try {
+        data = JSON.parse(body);
+    }
+    catch { /* not JSON */ }
+    if (res.status !== 200) {
+        throw new Error(`Starting the test call failed (HTTP ${res.status}): ${data.message || body.slice(0, 300) || 'no body'}`);
+    }
+    if (!data.token)
+        throw new Error('The test-call server answered without a LiveKit token, so there is no room to join.');
+    return { token: data.token, callSid: data.call_sid };
+}
+/** Swappable for tests: the native LiveKit module is loaded only when a test call starts. */
+exports.deps = {
+    rtc: () => {
+        try {
+            return require('@livekit/rtc-node');
+        }
+        catch {
+            throw new Error('Live tests need @livekit/rtc-node, which did not install on this machine. '
+                + 'Run: npm install --global @livekit/rtc-node, or reinstall cku on a supported platform '
+                + '(Linux, macOS or Windows, x64 or arm64).');
+        }
+    },
+};
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+class LiveSession {
+    callSid;
+    events = [];
+    ended = false;
+    room;
+    agentState = '';
+    sawState = false;
+    sawHistory = false;
+    agentMessages = 0;
+    openStreams = 0;
+    lastActivity = Date.now();
+    lastSent = '';
+    segments = new Map();
+    constructor(callSid) {
+        this.callSid = callSid;
+    }
+    /** Join the room and collect the agent's opening turn (empty when the agent waits for the caller). */
+    static async open(token, callSid, opts = {}) {
+        const rtc = exports.deps.rtc();
+        const s = new LiveSession(callSid);
+        const room = new rtc.Room();
+        s.room = room;
+        const touch = () => { s.lastActivity = Date.now(); };
+        const push = (e) => { const ev = { ...e, t: Date.now() }; s.events.push(ev); touch(); return ev; };
+        const readAttrs = (attrs) => {
+            if (!attrs)
+                return;
+            if ('lk.agent.state' in attrs) {
+                s.agentState = attrs['lk.agent.state'];
+                s.sawState = true;
+                touch();
+            }
+            if (attrs.current_capability)
+                push({ type: 'capability', capability: attrs.current_capability });
+        };
+        // CK_TEST_DEBUG=<file> appends every raw room event, for when the worker's protocol drifts.
+        const debug = (kind, data) => {
+            if (process.env.CK_TEST_DEBUG)
+                (0, fs_1.appendFileSync)(process.env.CK_TEST_DEBUG, `${new Date().toISOString()} ${kind} ${JSON.stringify(data)}\n`);
+        };
+        room.registerTextStreamHandler('lk.transcription', async (reader, from) => {
+            s.openStreams++;
+            touch();
+            try {
+                const text = String(await reader.readAll()).trim();
+                debug('transcription', { from: from.identity, attributes: reader.info?.attributes, text });
+                if (!text || from.identity === exports.TEST_IDENTITY || text === s.lastSent)
+                    return;
+                const seg = reader.info?.attributes?.['lk.segment_id'];
+                const prior = seg && s.segments.get(seg);
+                if (prior) {
+                    prior.text = text;
+                    touch();
+                    return;
+                }
+                const ev = push({ type: 'agent', text });
+                if (seg)
+                    s.segments.set(seg, ev);
+            }
+            finally {
+                s.openStreams--;
+            }
+        });
+        room.on('dataReceived', (payload, p, _k, topic) => {
+            debug('data', { from: p?.identity, topic, payload: new TextDecoder().decode(payload).slice(0, 2000) });
+            if (topic !== 'lk.history')
+                return;
+            try {
+                const data = JSON.parse(new TextDecoder().decode(payload));
+                if (data.type === 'message') {
+                    // Duplicates the transcript text; only the count matters (see the header).
+                    s.sawHistory = true;
+                    if (data.role === 'assistant')
+                        s.agentMessages++;
+                    touch();
+                }
+                else if (data.type === 'function') {
+                    let args = data.arguments;
+                    try {
+                        if (typeof args === 'string')
+                            args = JSON.parse(args || '{}');
+                    }
+                    catch { /* keep the string */ }
+                    push({ type: 'function', name: data.name, arguments: args });
+                }
+                else {
+                    push({ type: 'history', data });
+                }
+            }
+            catch { /* not JSON */ }
+        });
+        room.on('participantConnected', (p) => { debug('joined', { identity: p.identity, kind: p.kind, attributes: p.attributes }); readAttrs(p.attributes); });
+        room.on('participantAttributesChanged', (changed, p) => {
+            debug('attributes', { from: p?.identity, changed });
+            if (p?.identity !== exports.TEST_IDENTITY)
+                readAttrs(changed);
+        });
+        const end = () => { if (!s.ended) {
+            s.ended = true;
+            push({ type: 'ended' });
+        } };
+        room.on('participantDisconnected', (p) => { if (p?.identity !== exports.TEST_IDENTITY)
+            end(); });
+        room.on('disconnected', (reason) => { debug('disconnected', { reason }); end(); });
+        await room.connect(exports.LIVEKIT_URL, token, { autoSubscribe: false });
+        for (const p of room.remoteParticipants?.values?.() || [])
+            readAttrs(p.attributes);
+        const greeting = await s.waitTurn(opts.greetingTimeoutMs ?? 20_000, 0);
+        return { session: s, greeting };
+    }
+    /**
+     * Wait until the agent has finished its turn: it spoke or called a function since `from` (and,
+     * once the worker is known to send them, a finished-message item arrived on `lk.history`), no transcript
+     * stream is still open, the agent reports `listening` (or never reports a state), and nothing
+     * new has arrived for a short settle window. `lk.agent.state` makes the window short; without
+     * it a longer quiet period has to stand in.
+     */
+    async waitTurn(timeoutMs, from = this.events.length, messagesBefore = this.agentMessages) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline && !this.ended) {
+            const spoke = this.events.slice(from).some((e) => e.type === 'agent' || e.type === 'function');
+            const got = spoke && (!this.sawHistory || this.agentMessages > messagesBefore);
+            const idle = this.openStreams === 0 && (!this.sawState || this.agentState === 'listening');
+            const quiet = Date.now() - this.lastActivity >= (this.sawState ? 700 : 2500);
+            if (got && idle && quiet)
+                break;
+            await sleep(100);
+        }
+        return this.events.slice(from);
+    }
+    async say(text, timeoutMs = 60_000) {
+        if (this.ended)
+            return [{ type: 'ended', t: Date.now() }];
+        const from = this.events.length;
+        const messagesBefore = this.agentMessages;
+        this.events.push({ type: 'user', text, t: Date.now() });
+        this.lastSent = text.trim();
+        this.lastActivity = Date.now();
+        await this.room.localParticipant.sendText(text, { topic: 'lk.chat' });
+        // Give the agent a moment to leave `listening`, so a still-idle state is not read as done.
+        if (this.sawState) {
+            const until = Date.now() + 3000;
+            while (this.agentState === 'listening' && Date.now() < until && !this.ended)
+                await sleep(50);
+        }
+        return this.waitTurn(timeoutMs, from + 1, messagesBefore);
+    }
+    async close() {
+        try {
+            await this.room?.disconnect();
+        }
+        catch { /* already gone */ }
+        try {
+            exports.deps.rtc().dispose?.();
+        }
+        catch { /* best effort */ }
+    }
+}
+exports.LiveSession = LiveSession;
+/** One line per event, numbered by turn, for people and for the judge. */
+function formatTranscript(events) {
+    const lines = [];
+    let turn = 0;
+    for (const e of events) {
+        if (e.type === 'agent')
+            lines.push(`T${++turn} agent: ${e.text}`);
+        else if (e.type === 'user')
+            lines.push(`T${++turn} caller: ${e.text}`);
+        else if (e.type === 'function')
+            lines.push(`   [function ${e.name} ${JSON.stringify(e.arguments ?? {})}]`);
+        else if (e.type === 'capability')
+            lines.push(`   [node: ${e.capability}]`);
+        else if (e.type === 'ended')
+            lines.push('   [call ended]');
+    }
+    return lines.join('\n');
+}
+// --- LLM caller and judge -------------------------------------------------------------------
+/** Every provider here speaks the OpenAI chat-completions shape, so one client covers them all. */
+exports.LLM_PRESETS = {
+    openai: { url: 'https://api.openai.com/v1', env: 'OPENAI_API_KEY', model: 'gpt-4.1-mini' },
+    anthropic: { url: 'https://api.anthropic.com/v1', env: 'ANTHROPIC_API_KEY', model: 'claude-haiku-5-5' },
+    gemini: { url: 'https://generativelanguage.googleapis.com/v1beta/openai', env: 'GEMINI_API_KEY', model: 'gemini-2.5-flash' },
+    deepseek: { url: 'https://api.deepseek.com/v1', env: 'DEEPSEEK_API_KEY', model: 'deepseek-chat' },
+    groq: { url: 'https://api.groq.com/openai/v1', env: 'GROQ_API_KEY', model: 'llama-3.3-70b-versatile' },
+    openrouter: { url: 'https://openrouter.ai/api/v1', env: 'OPENROUTER_API_KEY', model: 'openai/gpt-4.1-mini' },
+    ollama: { url: 'http://localhost:11434/v1', model: 'llama3.1' },
+};
+/**
+ * Pick the provider: --llm, else --llm-url (custom, key in CKU_LLM_API_KEY), else the first
+ * preset whose key is in the environment. Keys only come from the environment, never a flag,
+ * so they stay out of shell history and process listings.
+ */
+function resolveLlm(opts) {
+    const names = Object.keys(exports.LLM_PRESETS);
+    let name = opts.llm;
+    if (!name && opts.llmUrl)
+        name = 'custom';
+    if (!name)
+        name = names.find((n) => exports.LLM_PRESETS[n].env && process.env[exports.LLM_PRESETS[n].env]);
+    if (!name) {
+        throw new Error(`No LLM for the simulated caller. Set one of ${names.filter((n) => exports.LLM_PRESETS[n].env).map((n) => exports.LLM_PRESETS[n].env).join(', ')}, `
+            + 'or pass --llm ollama, or --llm-url <OpenAI-compatible base URL> with the key in CKU_LLM_API_KEY. '
+            + 'To play the caller yourself instead, use: cku test start <agentId>');
+    }
+    if (name === 'custom') {
+        if (!opts.llmUrl)
+            throw new Error('--llm custom needs --llm-url <OpenAI-compatible base URL>.');
+        if (!opts.llmModel)
+            throw new Error('--llm-url needs --llm-model <model id>.');
+        return { name, url: opts.llmUrl.replace(/\/+$/, ''), key: process.env.CKU_LLM_API_KEY, model: opts.llmModel };
+    }
+    const p = exports.LLM_PRESETS[name];
+    if (!p)
+        throw new Error(`Unknown --llm "${name}". Use one of: ${names.join(', ')}, custom.`);
+    const key = process.env.CKU_LLM_API_KEY || (p.env ? process.env[p.env] : undefined);
+    if (p.env && !key)
+        throw new Error(`--llm ${name} needs ${p.env} (or CKU_LLM_API_KEY) set in the environment.`);
+    return { name, url: (opts.llmUrl || p.url).replace(/\/+$/, ''), key, model: opts.llmModel || p.model };
+}
+async function chatComplete(cfg, messages, temperature = 0.7) {
+    const res = await fetch(`${cfg.url}/chat/completions`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...(cfg.key ? { Authorization: `Bearer ${cfg.key}` } : {}) },
+        body: JSON.stringify({ model: cfg.model, messages, temperature }),
+        signal: AbortSignal.timeout(120_000),
+    });
+    const body = await res.text();
+    if (!res.ok)
+        throw new Error(`${cfg.name} (${cfg.model}) returned HTTP ${res.status}: ${body.slice(0, 300)}`);
+    const content = JSON.parse(body)?.choices?.[0]?.message?.content;
+    return Array.isArray(content) ? content.map((c) => c.text ?? '').join('') : String(content ?? '');
+}
+exports.END_MARK = '[END]';
+function callerSystemPrompt(s) {
+    return [
+        'You are role-playing a person on a phone call with a voice agent. Stay in character the whole call.',
+        s.persona ? `Who you are: ${s.persona}` : '',
+        `What happens in this call: ${s.prompt}`,
+        'Rules:',
+        '- Reply with only the words you say out loud: one short spoken turn, usually one or two sentences. No stage directions, no quotes, no labels.',
+        '- Speak the way this person would, in their language and register (Hindi, Hinglish, English, ...).',
+        '- Never say you are a test, a simulation or an AI.',
+        `- When the call is over for you (goal done, you give up, or the agent said goodbye), end your reply with ${exports.END_MARK}. Reply with only ${exports.END_MARK} if there is nothing left to say.`,
+    ].filter(Boolean).join('\n');
+}
+/** The caller's next line, and whether it hangs up after it. */
+function parseCallerLine(raw) {
+    const end = raw.includes(exports.END_MARK);
+    const text = raw.replace(exports.END_MARK, '').replace(/^\s*(caller|me|you)\s*:\s*/i, '').trim().replace(/^"(.*)"$/s, '$1');
+    return { text, end };
+}
+function judgeMessages(criteria, events) {
+    return [
+        {
+            role: 'system',
+            content: 'You grade a test call between a simulated caller and a voice agent. Judge only from the transcript. '
+                + 'Split the success criteria into separate checks. A check passes only if the transcript shows it; anything the '
+                + 'criteria forbid fails. Cite the turn (T3) or function line that decides each check. Answer with JSON only: '
+                + '{"pass": boolean, "criteria": [{"criterion": string, "pass": boolean, "evidence": string, "reason": string}], "summary": string}. '
+                + '"pass" is true only if every check passes.',
+        },
+        { role: 'user', content: `Success criteria:\n${criteria}\n\nTranscript:\n${formatTranscript(events)}` },
+    ];
+}
+/** The judge's JSON, tolerating a code fence or prose around it. A reply with no JSON is INVALID, not FAIL. */
+function parseVerdict(raw) {
+    const m = raw.match(/\{[\s\S]*\}/);
+    try {
+        const v = JSON.parse(m ? m[0] : raw);
+        const criteria = Array.isArray(v.criteria) ? v.criteria : [];
+        return { pass: v.pass === true && criteria.every((c) => c.pass !== false), criteria, summary: String(v.summary ?? '') };
+    }
+    catch {
+        return { pass: false, criteria: [], summary: `Judge did not return JSON: ${raw.slice(0, 200)}`, invalid: true };
+    }
+}

package/dist/lib/liveVoiceCheck.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkVoiceConfigs = checkVoiceConfigs;
+exports.savedVoices = savedVoices;
+/** Validate TTS provider/model pairs against the account's live voice catalogue. */
+const slug = (value) => value.toLowerCase().replace(/[^a-z0-9]/g, '');
+async function checkVoiceConfigs(api, entries, saved) {
+    const todo = Object.entries(entries).filter(([, config]) => !!config && typeof config === 'object' && !Array.isArray(config) && typeof config.voice_provider === 'string');
+    if (!todo.length)
+        return;
+    let providers;
+    try {
+        providers = (await api.getVoiceCatalog()).providers || [];
+    }
+    catch (error) {
+        console.error(`! Could not check voices against the live catalogue (${error.message}); the backend will still validate.`);
+        return;
+    }
+    let savedPairs;
+    const alreadySaved = async (config) => {
+        if (!saved)
+            return false;
+        if (!savedPairs) {
+            try {
+                savedPairs = new Set((await saved()).filter((voice) => typeof voice?.voice_provider === 'string')
+                    .map((voice) => `${slug(voice.voice_provider)}|${voice.voice_model ?? ''}`));
+            }
+            catch {
+                savedPairs = new Set();
+            }
+        }
+        return savedPairs.has(`${slug(String(config.voice_provider))}|${config.voice_model ?? ''}`);
+    };
+    for (const [label, raw] of todo) {
+        const config = raw;
+        const name = String(config.voice_provider);
+        const provider = providers.find((candidate) => slug(candidate.provider) === slug(name));
+        if (!provider) {
+            if (await alreadySaved(config))
+                continue;
+            throw new Error(`Unknown voice_provider "${name}" in ${label}\n  allowed (live): ${providers.map((candidate) => candidate.provider).join(', ')}`);
+        }
+        if (name !== provider.provider)
+            config.voice_provider = provider.provider;
+        const models = provider.models || [];
+        if (typeof config.voice_model === 'string' && config.voice_model && models.length && !models.includes(config.voice_model)) {
+            if (await alreadySaved(config))
+                continue;
+            throw new Error(`"${config.voice_model}" is not a ${provider.provider} voice_model (in ${label})\n  allowed (live): ${models.join(', ')}`);
+        }
+    }
+}
+function savedVoices(version) {
+    return [version?.voice_configuration, version?.secondary_voice_configuration, ...(version?.agentMemory?.voice_rotation_config?.voices || [])].filter(Boolean);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "callkaro-cli-unofficial",
-  "version": "0.9.4",
+  "version": "0.10.0",
   "license": "Apache-2.0",
   "description": "Unofficial fork of the CallKaro CLI — manage your voice AI agents from the terminal",
   "bin": {
@@ -48,5 +48,8 @@
     "cli",
     "agents",
     "telephony"
-  ]
+  ],
+  "optionalDependencies": {
+    "@livekit/rtc-node": "^1.2.2"
+  }
 }