callkaro-cli-unofficial 0.1.0

package/dist/lib/agentImport.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Client-side import validation, mirrored from the web importer
+ * (Frontend/src/components/agent/ImportAgentV2.jsx) so a bad file is rejected
+ * with a clear message before it ever reaches the backend. Keep this list in
+ * sync with that component.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_LEVEL_KEYS = exports.REQUIRED_KEYS = void 0;
+exports.missingKeys = missingKeys;
+exports.agentLevelMismatches = agentLevelMismatches;
+/** Fields every agent JSON must contain (same set the web importer checks). */
+exports.REQUIRED_KEYS = [
+    'postcallmodel', 'useOthersDropOffReason', 'name', 'systemprompt',
+    'auto_reschedule', 'conversion_reason', 'model', 'transcriber',
+    'voice_configuration', 'inboundPhoneNumbers', 'outboundPhoneNumber',
+    'secondaryOutboundPhoneNumber', 'bgNoise', 'bgNoiseVolume', 'voicemail_msg',
+    'voicemail_custom_msg', 'noise_cancellation', 'speakfirst', 'speakfirst_inbound',
+    'end_call_msg', 'functions', 'knowledges', 'temperature', 'vad_configuration',
+    'time_limit', 'postcall', 'webhook', 'initial_pause_outbound',
+    'initial_pause_inbound', 'silence_count', 'silence_language', 'default_language',
+    'silence_wait', 'silence_mode', 'silence_instructions', 'silence_prompts',
+    'systempromptType', 'role', 'goal', 'instructions', 'callFlow', 'guardrails',
+    'rebuttals', 'language_switching', 'language_switching_instructions',
+    'language_lockin_time', 'allowed_languages', 'language_switch_min_words',
+];
+/**
+ * Agent-level (as opposed to version-level) fields. In a multi-version import
+ * these must be identical across every entry, since they all become one agent.
+ */
+exports.AGENT_LEVEL_KEYS = new Set([
+    'folderId', 'name', 'phoneNumber', 'inboundPhoneNumbers', 'outboundPhoneNumber',
+    'secondaryOutboundPhoneNumber', 'whatsappPhoneNumber', 'whatsappInboundPhoneNumber',
+    'publishedVersionId', 'lastpublisedDate', 'abTestVersions', 'abTestEnabled', '_id',
+    'default_agent_language', 'useMultiTranscribers', 'publishedVersionsByLanguage',
+    'agentStatus',
+]);
+/** Required keys absent from a single entry. */
+function missingKeys(entry) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+        return [...exports.REQUIRED_KEYS];
+    return exports.REQUIRED_KEYS.filter((k) => !(k in entry));
+}
+/** Agent-level fields that differ from the first entry (multi-version import). */
+function agentLevelMismatches(entries) {
+    if (entries.length < 2)
+        return [];
+    const ref = entries[0];
+    const out = [];
+    for (let i = 1; i < entries.length; i++) {
+        for (const key of exports.AGENT_LEVEL_KEYS) {
+            if (!(key in ref) && !(key in entries[i]))
+                continue;
+            if (JSON.stringify(ref[key]) !== JSON.stringify(entries[i][key])) {
+                out.push({ key, entry: i + 1, expected: ref[key], got: entries[i][key] });
+            }
+        }
+    }
+    return out;
+}

package/dist/lib/agentUpdate.js

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENUMS = exports.STRING_ARRAY_KEYS = exports.REPLACE_WHOLESALE_KEYS = void 0;
+exports.applyLiveModels = applyLiveModels;
+exports.validateEnums = validateEnums;
+exports.validateCallSettings = validateCallSettings;
+exports.validateProviderConfigs = validateProviderConfigs;
+exports.preparePatch = preparePatch;
+exports.coerce = coerce;
+exports.deepMerge = deepMerge;
+exports.mergeWholesaleKeys = mergeWholesaleKeys;
+exports.isAgentLevelKey = isAgentLevelKey;
+exports.normalizeStringArray = normalizeStringArray;
+const agentImport_1 = require("./agentImport");
+const catalog_1 = require("./catalog");
+/**
+ * Helpers for `ck agents update` — turning `--set '{json}'` / `--file` input
+ * into a clean update payload that matches how the backend `updateAgent`
+ * controller treats fields.
+ */
+/**
+ * Version-level object fields the backend replaces *wholesale* rather than
+ * shallow-merging (`full_keys` in updateAgent). A partial update to one of these
+ * would wipe the others, so for dotted paths into them we deep-merge locally
+ * against the current value and send the complete object.
+ */
+exports.REPLACE_WHOLESALE_KEYS = new Set([
+    'preFormatVariables', 'customPronunciations', 'transcriber', 'secondary_transcriber',
+    'voice_configuration', 'secondary_voice_configuration', 'callFlow_json',
+    'variableSource', 'callPropertyMapping',
+]);
+/** 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',
+]);
+/**
+ * Which live catalogue list governs which field.
+ *
+ * The server scopes models per slot — `post-call` has 9 entries and does NOT
+ * include `gpt-4o` or `o4-mini`, while `agent` has 44 and does. Validating every
+ * model field against one flat list is therefore wrong in both directions.
+ */
+const MODEL_SLOTS = {
+    model: 'agent',
+    secondary_model: 'agent',
+    postcallmodel: 'post-call',
+};
+/**
+ * The shipped per-slot lists from `catalog.json`, used when no dashboard session
+ * is present. This was a hand-written list of 7 ids while the server accepted 44
+ * for agent models, so it rejected ~37 working models. Reading the same file the
+ * voice and transcriber tables come from means `npm run catalog:check` covers
+ * models too, and there is one place to refresh.
+ *
+ * The empty list is a real possibility (a `--no-server` sync, a truncated file),
+ * and an empty allow-set would reject everything, so it falls back to the union:
+ * strictly more permissive, and the drift check flags the file.
+ */
+function shippedModels(slot) {
+    const list = catalog_1.LLM_MODELS[slot];
+    if (Array.isArray(list) && list.length)
+        return list;
+    return [...new Set(Object.values(catalog_1.LLM_MODELS).flat())];
+}
+/** Fields with a fixed set of valid values — a wrong value is a clear error, not a 500. */
+exports.ENUMS = {
+    default_language: ['en', 'hi', 'kn', 'ta', 'te', 'mr', 'gu', 'bn', 'ml'],
+    default_agent_language: ['en', 'hi', 'kn', 'ta', 'te', 'mr', 'gu', 'bn', 'ml'],
+    silence_language: ['en', 'hi', 'kn', 'ta', 'te', 'mr', 'gu', 'bn', 'ml', 'multi'],
+    silence_mode: ['default', 'custom', 'dynamic', 'ignore'],
+    caching_strategy: ['response', 'none', 'sentence'],
+    noise_cancellation_strategy: ['aicoustics', 'dtln', 'deepfilternet', 'noisereduce'],
+    agentStatus: ['live', 'in-progress'],
+    model: shippedModels('agent'),
+    secondary_model: shippedModels('agent'),
+    postcallmodel: shippedModels('post-call'),
+};
+/**
+ * Replace the model fallbacks with the server's own per-slot lists.
+ *
+ * Called by the commands when a dashboard session is available. Mutating ENUMS
+ * rather than threading a parameter keeps `preparePatch` and `validateEnums`
+ * synchronous and unchanged for every existing caller and test.
+ *
+ * A field whose slot is missing from the response keeps its fallback, so a
+ * partial response can never silently widen or narrow validation.
+ */
+function applyLiveModels(catalogs) {
+    const slots = catalogs?.llmModels;
+    if (!slots)
+        return false;
+    let applied = 0;
+    for (const [field, slot] of Object.entries(MODEL_SLOTS)) {
+        const list = slots[slot];
+        if (Array.isArray(list) && list.length) {
+            exports.ENUMS[field] = list;
+            applied += 1;
+        }
+    }
+    return applied > 0;
+}
+/** Throw if any field in `obj` carries a value outside its allowed set. */
+function validateEnums(obj) {
+    for (const [key, val] of Object.entries(obj)) {
+        if (exports.ENUMS[key] && typeof val === 'string' && !exports.ENUMS[key].includes(val)) {
+            // Point at the right list rather than dumping 44 ids into the message.
+            const slot = MODEL_SLOTS[key];
+            throw new Error(`Invalid value for "${key}": "${val}"\n` +
+                (slot
+                    ? `  The server lists ${exports.ENUMS[key].length} model(s) for "${slot}". Run \`cku models --slot ${slot}\` to see them.`
+                    : `  allowed: ${exports.ENUMS[key].join(', ')}`));
+        }
+    }
+}
+/** Validate call-setting fields whose shape cannot be expressed as a simple enum. */
+function validateCallSettings(obj) {
+    if ('noise_cancellation' in obj && typeof obj.noise_cancellation !== 'boolean') {
+        throw new Error('Invalid value for "noise_cancellation": expected a boolean');
+    }
+    if ('noise_cancellation_strength' in obj) {
+        const strength = obj.noise_cancellation_strength;
+        if (typeof strength !== 'number' || !Number.isFinite(strength) || strength < 0.05 || strength > 1) {
+            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 (!Array.isArray(punctuations) || punctuations.some((v) => typeof v !== 'string')) {
+            throw new Error('Invalid value for "punctuations_to_remove": expected an array of strings');
+        }
+    }
+    if ('webhook_headers' in obj) {
+        const headers = obj.webhook_headers;
+        const valid = Array.isArray(headers) &&
+            headers.every((header) => {
+                if (!header || typeof header !== 'object' || Array.isArray(header))
+                    return false;
+                const row = header;
+                return typeof row.key_name === 'string' && typeof row.value === 'string';
+            });
+        if (!valid) {
+            throw new Error('Invalid value for "webhook_headers": expected an array of { key_name, value } strings');
+        }
+    }
+}
+/** The four voice/transcriber objects, and which catalogue validates each. */
+const PROVIDER_CONFIGS = [
+    { key: 'voice_configuration', kind: 'voice' },
+    { key: 'secondary_voice_configuration', kind: 'voice' },
+    { key: 'transcriber', kind: 'transcriber' },
+    { key: 'secondary_transcriber', kind: 'transcriber' },
+];
+/**
+ * Catch a bad provider or a model that belongs to a *different* provider before
+ * it reaches the database. Both mistakes persist silently and only surface as a
+ * broken call, so failing here is much cheaper.
+ *
+ * Patches may be partial (a dotted `--set` touching only `voice_speed`), so each
+ * check runs only when the keys it needs are actually present.
+ */
+function validateProviderConfigs(obj) {
+    for (const { key, kind } of PROVIDER_CONFIGS) {
+        const cfg = obj[key];
+        if (!cfg || typeof cfg !== 'object' || Array.isArray(cfg))
+            continue;
+        const c = cfg;
+        const providerKey = kind === 'voice' ? 'voice_provider' : 'transcriber_provider';
+        const modelKey = kind === 'voice' ? 'voice_model' : 'transcriber_model';
+        const providerName = c[providerKey];
+        if (typeof providerName !== 'string')
+            continue;
+        const provider = kind === 'voice' ? (0, catalog_1.findVoiceProvider)(providerName) : (0, catalog_1.findTranscriberProvider)(providerName);
+        if (!provider) {
+            const known = (kind === 'voice' ? catalog_1.VOICE_PROVIDERS : catalog_1.TRANSCRIBER_PROVIDERS).map((p) => p.name);
+            throw new Error(`Unknown ${providerKey} "${providerName}" in ${key}\n  allowed: ${known.join(', ')}`);
+        }
+        // Providers store the canonical spelling; "elevenlabs" must land as "Eleven Labs".
+        if (providerName !== provider.name)
+            c[providerKey] = provider.name;
+        const model = c[modelKey];
+        if (typeof model !== 'string' || !model)
+            continue;
+        if (!provider.models.length) {
+            throw new Error(`${provider.name} takes no ${modelKey} — remove it from ${key}.`);
+        }
+        if (!provider.models.some((m) => m.name === model)) {
+            throw new Error(`"${model}" is not a ${provider.name} ${modelKey} (in ${key})\n` +
+                `  allowed: ${provider.models.map((m) => m.name).join(', ')}`);
+        }
+    }
+}
+/**
+ * Validate + split a JSON object of fields for `ck agents update --set '{json}'`.
+ * Enums are checked, string-arrays normalized, and keys partitioned into
+ * agent-level vs version-level (the latter need a --versions target).
+ *
+ * `wholesaleKeys` lists the replace-wholesale objects present in the patch, so
+ * the caller can merge them against the agent's current value before sending.
+ */
+function preparePatch(obj) {
+    if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
+        throw new Error('--set must be a JSON object of fields, e.g. \'{"name":"x","temperature":5}\'');
+    }
+    const source = obj;
+    validateEnums(source);
+    validateCallSettings(source);
+    const patch = { ...source };
+    validateProviderConfigs(patch);
+    for (const key of Object.keys(patch)) {
+        if (exports.STRING_ARRAY_KEYS.has(key))
+            patch[key] = normalizeStringArray(patch[key]);
+    }
+    const versionKeys = Object.keys(patch).filter((k) => !isAgentLevelKey(k));
+    const wholesaleKeys = Object.keys(patch).filter((k) => exports.REPLACE_WHOLESALE_KEYS.has(k) && patch[k] && typeof patch[k] === 'object' && !Array.isArray(patch[k]));
+    return { patch, versionKeys, wholesaleKeys };
+}
+/** JSON-first value coercion: `true`→bool, `5`→num, `[...]`→array, else the raw string. */
+function coerce(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+/** Recursively merge `src` into `dst` (objects only; arrays/scalars replace). */
+function deepMerge(dst, src) {
+    if (typeof dst !== 'object' || dst === null || Array.isArray(dst))
+        return src;
+    const out = { ...dst };
+    for (const [k, v] of Object.entries(src)) {
+        out[k] = k in out ? deepMerge(out[k], v) : v;
+    }
+    return out;
+}
+/**
+ * Merge every replace-wholesale object in `patch` against the agent's current
+ * value, so a partial `--set voice_configuration:{voice_speed:1.3}` keeps the
+ * provider, id and language that the backend would otherwise drop.
+ *
+ * Safe when the object is complete too: merging a full object over itself is a
+ * no-op, so callers need not guess whether the user meant replace or merge.
+ */
+function mergeWholesaleKeys(patch, current) {
+    const out = { ...patch };
+    for (const key of exports.REPLACE_WHOLESALE_KEYS) {
+        if (out[key] && typeof out[key] === 'object' && !Array.isArray(out[key])) {
+            out[key] = deepMerge(current[key], out[key]);
+        }
+    }
+    return out;
+}
+function isAgentLevelKey(key) {
+    return agentImport_1.AGENT_LEVEL_KEYS.has(key);
+}
+/** Normalize a string-array field the way the web does: strings, trimmed, no empties. */
+function normalizeStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((v) => (typeof v === 'string' ? v.trim() : '')).filter((s) => s !== '');
+}

package/dist/lib/api.js

@@ -0,0 +1,287 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Api = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const types_1 = require("./types");
+/**
+ * The single place that talks to the CallKaro backend.
+ *
+ * `request()` owns the base URL, bearer token, JSON encoding, and error
+ * mapping — every command goes through it, so there is exactly one copy of that
+ * logic. Public methods map 1:1 to the `/cli/*` endpoints.
+ */
+class Api {
+    token;
+    baseUrl;
+    callBaseUrl;
+    constructor(baseUrl, callBaseUrl, token) {
+        this.token = token;
+        this.baseUrl = baseUrl.replace(/\/+$/, '');
+        this.callBaseUrl = (callBaseUrl || baseUrl).replace(/\/+$/, '');
+    }
+    request(method, path, body) {
+        return this.requestTo(this.baseUrl, method, path, body);
+    }
+    /** Same as request(), but against a specific base URL (e.g. the call cloud). */
+    async requestTo(base, method, path, body) {
+        const headers = { 'Content-Type': 'application/json' };
+        if (this.token)
+            headers.Authorization = `Bearer ${this.token}`;
+        let res;
+        try {
+            res = await fetch(`${base}${path}`, {
+                method,
+                headers,
+                body: body === undefined ? undefined : JSON.stringify(body),
+            });
+        }
+        catch (err) {
+            throw new types_1.ApiError(0, `Cannot reach ${base} (${err.message})`);
+        }
+        const text = await res.text();
+        const data = text ? safeJson(text) : undefined;
+        if (!res.ok) {
+            throw new types_1.ApiError(res.status, data?.msg || data?.message || (typeof data?.error === 'string' ? data.error : undefined) ||
+                `Request failed (${res.status})`, parseErrorDetails(data?.errors));
+        }
+        return data;
+    }
+    // --- auth endpoints -------------------------------------------------------
+    registerStart(email) { return this.request('POST', '/cli/auth/register/start', { email }); }
+    registerVerify(input) { return this.request('POST', '/cli/auth/register/verify', input); }
+    login(email, password) { return this.request('POST', '/cli/auth/login', { email, password }); }
+    logout() { return this.request('POST', '/cli/auth/logout'); }
+    /** Begin browser sign-in: returns the code for the URL + a secret only we hold. */
+    browserStart() { return this.request('POST', '/cli/auth/browser/start'); }
+    /** Poll until the browser approves; returns the token exactly once. */
+    browserPoll(code, secret) {
+        return this.request('GET', `/cli/auth/browser/poll?code=${encodeURIComponent(code)}&secret=${encodeURIComponent(secret)}`);
+    }
+    me() { return this.request('GET', '/cli/auth/me'); }
+    // --- secrets --------------------------------------------------------------
+    listSecrets() { return this.request('GET', '/cli/secrets'); }
+    saveSecrets(secrets) { return this.request('PUT', '/cli/secrets', { secrets }); }
+    // --- agents ---------------------------------------------------------------
+    listAgents() { return this.request('GET', '/cli/agents'); }
+    getAgent(agentId, version) {
+        const qs = version ? `?version=${encodeURIComponent(version)}` : '';
+        return this.request('GET', `/cli/agents/${agentId}${qs}`);
+    }
+    listAgentVersions(agentId) { return this.request('GET', `/cli/agents/${agentId}/versions`); }
+    /** Clone a source version, optionally migrating its prompt mode and runtime config. */
+    cloneAgentVersion(agentId, sourceVersionId, body) {
+        return this.request('POST', `/cli/agents/${agentId}/versions?version=${encodeURIComponent(sourceVersionId)}`, body);
+    }
+    exportAgent(agentId, versionIds) {
+        return this.request('POST', `/cli/agents/${agentId}/export`, { versionIds });
+    }
+    createAgent(payload) { return this.request('POST', '/cli/agents', payload); }
+    /** Import one agent with several versions from an array of exported objects. */
+    importMultiple(payloads) { return this.request('POST', '/cli/agents/import-multiple', payloads); }
+    /** Update agent-level fields and/or one version's fields. */
+    updateAgent(agentId, version, body) {
+        const qs = version ? `?version=${encodeURIComponent(version)}` : '';
+        return this.request('PUT', `/cli/agents/${agentId}${qs}`, body);
+    }
+    publishVersion(agentId, versionId) {
+        return this.request('PUT', `/cli/agents/${agentId}/publish?version=${encodeURIComponent(versionId)}`);
+    }
+    toggleVersionActive(agentId, versionId) {
+        return this.request('PUT', `/cli/agents/${agentId}/toggle-active?version=${encodeURIComponent(versionId)}`);
+    }
+    /** Enable A/B testing with weighted versions (reuses updateAgent). */
+    enableAbTest(agentId, abTestVersions) {
+        return this.updateAgent(agentId, undefined, { abTestEnabled: true, abTestVersions });
+    }
+    disableAbTest(agentId) {
+        return this.updateAgent(agentId, undefined, { abTestEnabled: false });
+    }
+    // --- chat agents ----------------------------------------------------------
+    listChatAgentModels() { return this.request('GET', '/cli/chat-agents/models'); }
+    async listChatAgentTemplates(provider = 'meta') {
+        const response = await this.request('GET', `/cli/chat-agents/templates/${provider}`);
+        const records = provider === 'aisensy' ? response.campaigns || [] : response.templates || [];
+        const templates = records.map((record) => {
+            const source = record;
+            const nested = provider === 'aisensy' && source.template && typeof source.template === 'object' ? source.template : source;
+            const id = String(source.id ?? nested.id ?? source.name ?? nested.name ?? '');
+            const name = String(source.name ?? nested.name ?? id);
+            return {
+                ...source,
+                id,
+                name,
+                provider,
+                language: nested.language,
+                category: nested.category,
+                status: source.status ?? nested.status,
+                ...(provider === 'aisensy' ? { campaignId: id, campaignName: name } : {}),
+            };
+        });
+        return { ...response, templates };
+    }
+    async getChatAgentTemplate(templateId, provider = 'meta') {
+        const { templates } = await this.listChatAgentTemplates(provider);
+        const template = templates.find((c) => String(c.id) === templateId);
+        if (!template)
+            throw new Error(`${provider} template "${templateId}" was not found for this account.`);
+        return { template };
+    }
+    listChatAgents() { return this.request('GET', '/cli/chat-agents'); }
+    getChatAgent(agentId, version) {
+        const query = version ? `?version=${encodeURIComponent(version)}` : '';
+        return this.request('GET', `/cli/chat-agents/${agentId}${query}`);
+    }
+    createChatAgent(payload) { return this.request('POST', '/cli/chat-agents', payload); }
+    updateChatAgent(agentId, version, payload) {
+        const query = version ? `?version=${encodeURIComponent(version)}` : '';
+        return this.request('PUT', `/cli/chat-agents/${agentId}${query}`, payload);
+    }
+    listChatAgentVersions(agentId) { return this.request('GET', `/cli/chat-agents/${agentId}/versions`); }
+    createChatAgentVersion(agentId, payload) {
+        return this.request('POST', `/cli/chat-agents/${agentId}/versions`, payload);
+    }
+    publishChatAgentVersion(agentId, versionId) {
+        return this.request('POST', `/cli/chat-agents/${agentId}/publish`, { versionId });
+    }
+    // --- phone numbers --------------------------------------------------------
+    listNumbers() { return this.request('GET', '/cli/numbers'); }
+    numbersCatalog() { return this.request('GET', '/cli/numbers/catalog'); }
+    buyNumber(phoneNumberId, pricepernumber) {
+        return this.request('POST', '/cli/numbers/buy', { phoneNumberId, pricepernumber });
+    }
+    setSpam(phoneNumberId, spam) {
+        return this.request('PUT', `/cli/numbers/${phoneNumberId}/spam`, { spam });
+    }
+    releaseNumber(phoneNumberId) { return this.request('DELETE', `/cli/numbers/${phoneNumberId}`); }
+    // --- calls ----------------------------------------------------------------
+    listCalls(query = {}) { return this.request('GET', `/cli/calls${qs(query)}`); }
+    getCall(callId) { return this.request('GET', `/cli/calls/${callId}`); }
+    /** Place a single outbound call (real or test) — uses the call-cloud base URL. */
+    makeCall(body) { return this.requestTo(this.callBaseUrl, 'POST', '/cli/calls/make', body); }
+    /** Export call history. Returns raw bytes (CSV/xlsx), or JSON on the email/too-large path. */
+    async exportCalls(query = {}) {
+        const headers = {};
+        if (this.token)
+            headers.Authorization = `Bearer ${this.token}`;
+        const res = await fetch(`${this.baseUrl}/cli/calls/export${qs(query)}`, { headers });
+        const contentType = res.headers.get('content-type') || '';
+        if (contentType.includes('application/json')) {
+            const json = await res.text().then((t) => (t ? JSON.parse(t) : {}));
+            return { ok: res.ok, status: res.status, json, buffer: null };
+        }
+        const buffer = Buffer.from(await res.arrayBuffer());
+        return { ok: res.ok, status: res.status, json: null, buffer };
+    }
+    // --- ongoing calls --------------------------------------------------------
+    ongoingStatus() { return this.request('GET', '/cli/ongoing/status'); }
+    // `action` is a literal supplied by the caller (pause|resume|clear), never user
+    // input; the agent id travels in the body, so neither reaches the path unescaped.
+    ongoingAgent(action, agentId) {
+        return this.request('POST', `/cli/ongoing/agent/${action}`, { agent_id: agentId });
+    }
+    ongoingUser(action) { return this.request('POST', `/cli/ongoing/${action}`); }
+    // --- analytics ------------------------------------------------------------
+    analytics(query = {}) { return this.request('GET', `/cli/analytics${qs(query)}`); }
+    performance(query = {}) {
+        return this.request('GET', `/cli/analytics/performance${qs(query)}`);
+    }
+    versionAnalytics(agentId, query = {}) {
+        return this.request('GET', `/cli/analytics/performance/${agentId}${qs(query)}`);
+    }
+    // --- batch calls ----------------------------------------------------------
+    listBatches(query = {}) { return this.request('GET', `/cli/batches${qs(query)}`); }
+    getBatch(batchId) { return this.request('GET', `/cli/batches/${batchId}`); }
+    batchStatus(batchId) { return this.request('GET', `/cli/batches/${batchId}/status`); }
+    /** Create a batch from a local CSV (multipart upload → Azure → Python trigger). */
+    createBatch(filePath, fields) {
+        return this.uploadCsv(`${this.baseUrl}/cli/batches/create`, filePath, fields);
+    }
+    /** Schedule a batch from a local CSV for a future time (multipart upload). */
+    scheduleBatch(filePath, fields) {
+        return this.uploadCsv(`${this.baseUrl}/cli/batches/schedule`, filePath, fields);
+    }
+    sendNextTry(batchId, maxTryCount) {
+        return this.request('POST', `/cli/batches/${batchId}/send-next-try`, { max_try_count: maxTryCount });
+    }
+    sendUntriggered(batchId) { return this.request('POST', `/cli/batches/${batchId}/send-untriggered`, {}); }
+    batchDownload(batchId, kind) { return this.request('GET', `/cli/batches/${batchId}/${kind}`); }
+    async uploadCsv(url, filePath, fields) {
+        const form = new FormData();
+        form.append('file', new Blob([(0, fs_1.readFileSync)(filePath)], { type: 'text/csv' }), (0, path_1.basename)(filePath));
+        for (const [k, v] of Object.entries(fields))
+            if (v !== undefined && v !== '')
+                form.append(k, v);
+        const headers = {};
+        // Let fetch set the multipart boundary — do not set Content-Type here.
+        if (this.token)
+            headers.Authorization = `Bearer ${this.token}`;
+        const res = await fetch(url, { method: 'POST', headers, body: form });
+        const text = await res.text();
+        const data = text ? safeJson(text) : {};
+        if (!res.ok)
+            throw new types_1.ApiError(res.status, data?.msg || `Request failed (${res.status})`);
+        return data;
+    }
+    // --- voices ---------------------------------------------------------------
+    /** Providers, models, fields, and controls available to the owning account. */
+    getVoiceCatalog() { return this.request('GET', '/cli/voices/catalog'); }
+    /** Voices for one account-authorized provider. */
+    getProviderVoices(provider, params = {}) {
+        return this.request('GET', `/cli/voices/provider/${encodeURIComponent(provider)}${qs(params)}`);
+    }
+    // --- simulations ----------------------------------------------------------
+    createTestCase(body) { return this.request('POST', '/cli/simulations/test-cases', body); }
+    listTestCases(agentId) {
+        return this.request('GET', `/cli/simulations/test-cases${qs({ agentId })}`);
+    }
+    updateTestCase(id, body) { return this.request('PUT', `/cli/simulations/test-cases/${id}`, body); }
+    deleteTestCase(id) { return this.request('DELETE', `/cli/simulations/test-cases/${id}`); }
+    runSimulation(body) { return this.request('POST', '/cli/simulations/runs', body); }
+    listSimulationRuns(agentId) { return this.request('GET', `/cli/simulations/runs${qs({ agentId })}`); }
+    simulationResults(batchId) { return this.request('GET', `/cli/simulations/results${qs({ batchId })}`); }
+    // --- audit strategies (AI Auditor) -----------------------------------------
+    listAuditStrategies(agentId) {
+        return this.request('GET', `/cli/audit-strategies${qs({ agentId })}`);
+    }
+    getAuditFilterOptions(agentId) {
+        return this.request('GET', `/cli/audit-strategies/filter-options${qs({ agentId })}`);
+    }
+    listAuditModels() { return this.request('GET', '/cli/audit-strategies/models'); }
+    createAuditStrategy(body) { return this.request('POST', '/cli/audit-strategies', body); }
+    updateAuditStrategy(strategyId, body) {
+        return this.request('PUT', `/cli/audit-strategies/${strategyId}`, body);
+    }
+}
+exports.Api = Api;
+/** Build a `?a=1&b=2` query string, skipping undefined/empty values. */
+function qs(params) {
+    const parts = Object.entries(params)
+        .filter(([, v]) => v !== undefined && v !== '')
+        .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
+    return parts.length ? `?${parts.join('&')}` : '';
+}
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { msg: text };
+    }
+}
+function parseErrorDetails(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((detail) => {
+        if (!detail || typeof detail !== 'object')
+            return [];
+        const candidate = detail;
+        if (typeof candidate.message !== 'string')
+            return [];
+        return [{
+                message: candidate.message,
+                path: typeof candidate.path === 'string' ? candidate.path : undefined,
+                code: typeof candidate.code === 'string' ? candidate.code : undefined,
+            }];
+    });
+}