neoagent 2.1.1 → 2.1.2

package/server/services/android/controller.js

@@ -88,6 +88,32 @@ function systemImageArch() {
   return 'x86_64';
 }
 
+function parseSystemImagePlatform(platformId) {
+  const stable = String(platformId || '').match(/^android-(\d+)$/);
+  if (stable) {
+    return {
+      platformId,
+      apiLevel: Number(stable[1] || 0),
+      stable: true,
+    };
+  }
+
+  const preview = String(platformId || '').match(/^android-([A-Za-z][A-Za-z0-9_-]*)$/);
+  if (preview) {
+    return {
+      platformId,
+      apiLevel: 0,
+      stable: false,
+    };
+  }
+
+  return {
+    platformId,
+    apiLevel: 0,
+    stable: false,
+  };
+}
+
 function sdkEnv() {
   const base = {
     ...process.env,
@@ -205,21 +231,51 @@ function parseLatestCmdlineToolsUrl(xml) {
   throw new Error(`Could not find a command line tools archive for ${tag}`);
 }
 
+function systemImageTagScore(tag) {
+  const value = String(tag || '').toLowerCase();
+  if (value.startsWith('google_apis_playstore')) return 50;
+  if (value.startsWith('google_apis')) return 40;
+  if (value === 'google_atd') return 30;
+  if (value === 'aosp_atd') return 20;
+  if (value === 'default') return 10;
+  return 0;
+}
+
 function chooseLatestSystemImage(listOutput) {
   const arch = systemImageArch();
   const matches = [];
-  const regex = new RegExp(`system-images;android-(\\d+);google_apis;${arch}`, 'g');
+  const regex = /system-images;(android-[^;\s]+);([^;\s]+);([^;\s]+)/g;
   let match = regex.exec(listOutput);
   while (match) {
+    if (match[3] !== arch) {
+      match = regex.exec(listOutput);
+      continue;
+    }
+
+    const platform = parseSystemImagePlatform(match[1]);
     matches.push({
-      apiLevel: Number(match[1] || 0),
       packageName: match[0],
+      platformId: match[1],
+      tag: match[2],
+      arch: match[3],
+      apiLevel: platform.apiLevel,
+      stable: platform.stable,
+      tagScore: systemImageTagScore(match[2]),
     });
     match = regex.exec(listOutput);
   }
 
-  matches.sort((a, b) => b.apiLevel - a.apiLevel);
-  return matches[0] || null;
+  const preferredMatches = matches.filter((candidate) => candidate.tagScore > 0);
+  const pool = preferredMatches.length > 0 ? preferredMatches : matches;
+
+  pool.sort((a, b) =>
+    Number(b.stable) - Number(a.stable) ||
+    b.apiLevel - a.apiLevel ||
+    b.tagScore - a.tagScore ||
+    a.packageName.localeCompare(b.packageName)
+  );
+
+  return pool[0] || null;
 }
 
 function parseApiLevelFromSystemImage(packageName) {
@@ -349,7 +405,7 @@ class AndroidController {
     const available = await this.#run(`${quoteShell(sdkmanager)} --sdk_root=${quoteShell(SDK_ROOT)} --list`, { timeout: 300000 });
     const latestSystemImage = chooseLatestSystemImage(available);
     if (!latestSystemImage) {
-      throw new Error(`No stable Google APIs system image found for ${systemImageArch()}`);
+      throw new Error(`No compatible Android system image found for ${systemImageArch()}`);
     }
 
     const state = readState();
@@ -401,7 +457,7 @@ class AndroidController {
     const available = await this.#run(`${quoteShell(sdkmanager)} --sdk_root=${quoteShell(SDK_ROOT)} --list`, { timeout: 300000 });
     const systemImage = chooseLatestSystemImage(available);
     if (!systemImage) {
-      throw new Error(`No stable Google APIs system image found for ${systemImageArch()}`);
+      throw new Error(`No compatible Android system image found for ${systemImageArch()}`);
     }
 
     await this.#run(`${quoteShell(sdkmanager)} --sdk_root=${quoteShell(SDK_ROOT)} "${systemImage.packageName}"`, { timeout: 300000 });
@@ -869,6 +925,9 @@ class AndroidController {
       emulatorPath: emulatorBinary(),
       serial: state.serial,
       emulatorPid: state.emulatorPid,
+      systemImage: state.systemImage || null,
+      apiLevel: Number(state.apiLevel || 0) || null,
+      avdSystemImage: state.avdSystemImage || null,
       logPath: state.logPath || null,
       lastLogLine,
       devices,

package/server/services/memory/manager.js

@@ -14,7 +14,7 @@ const { AGENT_DATA_DIR } = require('../../../runtime/paths');
 async function getActiveProvider(userId) {
   try {
     const { getSupportedModels } = require('../ai/models');
-    const models = await getSupportedModels();
+    const models = await getSupportedModels(userId);
     const rows = db.prepare('SELECT key, value FROM user_settings WHERE user_id = ? AND key IN (?, ?)')
       .all(userId || 1, 'default_chat_model', 'enabled_models');
 
@@ -33,7 +33,7 @@ async function getActiveProvider(userId) {
       : (Array.isArray(enabledIds) && enabledIds.length > 0 ? enabledIds[0] : null);
 
     if (modelId) {
-      const def = models.find(m => m.id === modelId);
+      const def = models.find(m => m.id === modelId && m.available !== false);
       if (def) return def.provider;
     }
   } catch { }

package/server/services/messaging/telegram.js

@@ -3,18 +3,6 @@
 const { BasePlatform } = require('./base');
 const TelegramBot = require('node-telegram-bot-api');
 
-/**
- * Whitelist entry format (prefixed strings):
- *   "user:ID"   → always respond in DMs, no mention needed
- *   "group:ID"  → respond in this group/supergroup when @mentioned
- *   "ID"        → legacy plain ID, treated as "user"
- *
- * Telegram group/supergroup IDs are negative numbers (e.g. -1001234567890).
- *
- * chatId emitted on message events:
- *   DMs:    "dm_<userId>"
- *   Groups: "<chatId>"  (negative integer as string)
- */
 class TelegramPlatform extends BasePlatform {
   constructor(config = {}) {
     super('telegram', config);
@@ -28,13 +16,10 @@ class TelegramPlatform extends BasePlatform {
 
     this._bot = null;
     this._botUser = null;
-    // In-memory ring buffer of recent messages per raw chatId (Telegram has no fetch history API for bots)
     this._contextBuffers = new Map();
     this._contextMaxSize = 25;
   }
 
-  // ── Lifecycle ──────────────────────────────────────────────────────────────
-
   async connect() {
     if (!this.botToken) throw new Error('Telegram bot token is required');
 
@@ -78,21 +63,15 @@ class TelegramPlatform extends BasePlatform {
   getStatus() { return this.status; }
   getAuthInfo() { return this._botUser ? { username: this._botUser.username, id: this._botUser.id } : null; }
 
-  // ── Whitelist ──────────────────────────────────────────────────────────────
-
-  // Inherits setAllowedEntries from BasePlatform
-
-  /** Returns {allowed, requireMention} */
   _checkAccess(msg) {
     const userId = String(msg.from.id);
-    const chatId = String(msg.chat.id); // negative for groups
+    const chatId = String(msg.chat.id);
     const isPrivate = msg.chat.type === 'private';
 
-    // Default behavior with no allow-list: respond in private chats and require @mention in groups.
     if (this.allowedEntries.size === 0) return { allowed: true, requireMention: !isPrivate };
 
     if (super._checkAccess(`user:${userId}`)) return { allowed: true, requireMention: false };
-    if (super._checkAccess(userId)) return { allowed: true, requireMention: false }; // legacy
+    if (super._checkAccess(userId)) return { allowed: true, requireMention: false };
     if (super._checkAccess(`group:${chatId}`)) return { allowed: true, requireMention: true };
 
     return { allowed: false, requireMention: false };
@@ -119,8 +98,6 @@ class TelegramPlatform extends BasePlatform {
       .trim();
   }
 
-  // ── Context buffer (since Telegram bots can't fetch message history) ───────
-
   _addToContext(rawChatId, entry) {
     if (!this._contextBuffers.has(rawChatId)) this._contextBuffers.set(rawChatId, []);
     const buf = this._contextBuffers.get(rawChatId);
@@ -132,8 +109,6 @@ class TelegramPlatform extends BasePlatform {
     return [...(this._contextBuffers.get(rawChatId) || [])];
   }
 
-  // ── Message handler ────────────────────────────────────────────────────────
-
   async _handleMessage(msg) {
     if (!msg.from || msg.from.is_bot) return;
 
@@ -146,7 +121,6 @@ class TelegramPlatform extends BasePlatform {
     const senderName = [msg.from.first_name, msg.from.last_name].filter(Boolean).join(' ')
       || msg.from.username || userId;
 
-    // Always record into context buffer (even blocked messages add context)
     this._addToContext(rawChatId, {
       author: senderName,
       content: text || (msg.photo ? '[photo]' : msg.document ? '[document]' : '[empty]'),
@@ -174,7 +148,6 @@ class TelegramPlatform extends BasePlatform {
       return;
     }
 
-    // Group entries require @mention to activate
     if (requireMention && !this._isMentioned(msg)) return;
 
     let content = requireMention ? this._stripMention(text) : text;
@@ -204,18 +177,12 @@ class TelegramPlatform extends BasePlatform {
     });
   }
 
-  // ── Send ───────────────────────────────────────────────────────────────────
-
-  /**
-   * to: "dm_<userId>" for DMs, or a raw chat ID (e.g. "-1001234567890") for groups
-   */
   async sendMessage(to, content, _options = {}) {
     if (!this._bot || this.status !== 'connected') throw new Error('Telegram not connected');
 
     const telegramChatId = to.startsWith('dm_') ? to.slice(3) : to;
     await this._bot.sendMessage(telegramChatId, content);
 
-    // Store outgoing message in context buffer
     if (this._botUser) {
       this._addToContext(telegramChatId, {
         author: `[bot] ${this._botUser.username}`,
@@ -232,7 +199,7 @@ class TelegramPlatform extends BasePlatform {
     try {
       const id = chatId.startsWith('dm_') ? chatId.slice(3) : chatId;
       await this._bot.sendChatAction(id, 'typing');
-    } catch { /* non-fatal */ }
+    } catch {}
   }
 }
 

package/server/services/messaging/telnyx.js

@@ -8,41 +8,35 @@ const { OpenAI } = require('openai');
 const { DATA_DIR, AGENT_DATA_DIR } = require('../../../runtime/paths');
 
 const AUDIO_DIR = path.join(DATA_DIR, 'telnyx-audio');
-const RECORDING_TURN_LIMIT_MS = 4000; // auto-stop recording after 4 s of silence
+const RECORDING_TURN_LIMIT_MS = 4000;
 
 class TelnyxVoicePlatform extends BasePlatform {
   constructor(config = {}) {
     super('telnyx', config);
     this.supportsVoice = true;
 
-    // Config fields set via the web UI connect modal
-    this.apiKey      = config.apiKey      || '';
+    this.apiKey = config.apiKey || '';
     this.phoneNumber = config.phoneNumber || '';
     this.connectionId = config.connectionId || '';
-    this.webhookUrl  = config.webhookUrl  || '';   // e.g. https://xyz.ngrok.io
-    this.ttsVoice    = config.ttsVoice   || 'alloy';
-    this.ttsModel    = config.ttsModel   || 'tts-1';
-    this.sttModel    = config.sttModel   || 'whisper-1';
-
-    // Allowed-numbers whitelist (empty = allow all)
-    this.allowedNumbers = Array.isArray(config.allowedNumbers) ? config.allowedNumbers : [];
-
-    // Secret code for non-whitelisted inbound callers (digits only; empty = feature disabled)
+    this.webhookUrl = config.webhookUrl || '';
+    this.ttsVoice = config.ttsVoice || 'alloy';
+    this.ttsModel = config.ttsModel || 'tts-1';
+    this.sttModel = config.sttModel || 'whisper-1';
+    this.allowedNumbers = Array.isArray(config.allowedNumbers)
+      ? config.allowedNumbers
+      : [];
     this.voiceSecret = String(config.voiceSecret || '').replace(/\D/g, '');
 
-    // Runtime state
-    this._sessions        = new Map(); // ccId → session object
-    this._recordingTimers = new Map(); // ccId → setTimeout handle
-    this._secretTimers    = new Map(); // ccId → secret-entry timeout handle
-    this._bannedNumbers   = new Map(); // normalizedNumber → ban expiry timestamp
-    this._client          = null;      // Telnyx SDK instance
-    this._openai          = null;      // OpenAI client
-    this._webhookToken    = null;      // resolved at connect time from TELNYX_WEBHOOK_TOKEN
-    this._thinkAudioFile  = null;      // pre-cached "hold" audio filename
+    this._sessions = new Map();
+    this._recordingTimers = new Map();
+    this._secretTimers = new Map();
+    this._bannedNumbers = new Map();
+    this._client = null;
+    this._openai = null;
+    this._webhookToken = null;
+    this._thinkAudioFile = null;
   }
 
-  // ── Lifecycle ──────────────────────────────────────────────────────────────
-
   async connect() {
     if (!this.apiKey || !this.phoneNumber || !this.connectionId || !this.webhookUrl) {
       throw new Error('Telnyx Voice requires apiKey, phoneNumber, connectionId, and webhookUrl');
@@ -54,14 +48,13 @@ class TelnyxVoicePlatform extends BasePlatform {
     const TelnyxClient = TelnyxSDK.default || TelnyxSDK;
     this._client = new TelnyxClient({ apiKey: this.apiKey });
 
-    // Resolve OpenAI key: env var → stored API_KEYS.json → none (fallback to Telnyx speak)
     let openAiKey = process.env.OPENAI_API_KEY;
     if (!openAiKey) {
       try {
         const keysPath = path.join(AGENT_DATA_DIR, 'API_KEYS.json');
         const keys = JSON.parse(fs.readFileSync(keysPath, 'utf8'));
         openAiKey = keys.OPENAI_API_KEY || keys.openai_api_key || keys.openai || null;
-      } catch { /* file missing or unreadable — fine */ }
+      } catch {}
     }
     if (openAiKey) {
       this._openai = new OpenAI({ apiKey: openAiKey });
@@ -70,13 +63,11 @@ class TelnyxVoicePlatform extends BasePlatform {
       console.warn('[TelnyxVoice] No OpenAI API key found — TTS will use Telnyx native speak (language auto-detected)');
     }
 
-    // Derive the full inbound webhook URL (with token) so it can be logged / displayed
     const token = process.env.TELNYX_WEBHOOK_TOKEN;
     this._webhookToken = token || null;
     const inboundUrl = `${this.webhookUrl}/api/telnyx/webhook${token ? `?token=${token}` : ''}`;
     console.log(`[TelnyxVoice] Inbound webhook URL (configure this in the Telnyx portal): ${inboundUrl}`);
 
-    // Pre-generate the "thinking" hold audio so it's instant during calls
     this._precacheThinkAudio();
 
     this.status = 'connected';
@@ -106,8 +97,6 @@ class TelnyxVoicePlatform extends BasePlatform {
   getStatus() { return this.status; }
   getAuthInfo() { return { phoneNumber: this.phoneNumber }; }
 
-  // ── Whitelist management ────────────────────────────────────────────────────
-
   setAllowedNumbers(numbers) {
     this.allowedNumbers = Array.isArray(numbers) ? numbers : [];
     console.log(`[TelnyxVoice] Whitelist updated: ${this.allowedNumbers.length} number(s)`);
@@ -169,19 +158,16 @@ class TelnyxVoicePlatform extends BasePlatform {
     if (t) { clearTimeout(t); this._secretTimers.delete(ccId); }
   }
 
-  // ── Session helpers ────────────────────────────────────────────────────────
-
   _initSession(ccId, callerNumber = '') {
     this._sessions.set(ccId, {
       callerNumber,
-      isProcessing:        false,
-      awaitingUserInput:   false,
-      isThinking:          false, // true while agent is processing — gates playback.ended mutations
-      replySent:           false, // prevents double-reply within one agent turn
+      isProcessing: false,
+      awaitingUserInput: false,
+      isThinking: false,
+      replySent: false,
       processedRecordings: new Set(),
-      // Secret-code gating (non-whitelisted callers)
-      awaitingSecret:      false,
-      secretDigits:        '',
+      awaitingSecret: false,
+      secretDigits: '',
     });
   }
 
@@ -210,8 +196,6 @@ class TelnyxVoicePlatform extends BasePlatform {
     if (t) { clearTimeout(t); this._recordingTimers.delete(ccId); }
   }
 
-  // ── Telnyx call-control wrappers ───────────────────────────────────────────
-
   _isTerminalError(err) {
     const errs = (err.error?.errors) || err.errors ||
                  (err.raw?.errors)   || (err.response?.data?.errors);
@@ -263,10 +247,8 @@ class TelnyxVoicePlatform extends BasePlatform {
     catch (err) { if (!this._isTerminalError(err)) throw err; }
   }
 
-  // ── Pre-cached think audio ─────────────────────────────────────────────────
-
   async _precacheThinkAudio() {
-    if (!this._openai) return; // will use Telnyx speak fallback at playback time
+    if (!this._openai) return;
     try {
       const file = `think_hold_${Date.now()}.mp3`;
       const filePath = path.join(AUDIO_DIR, file);
@@ -284,7 +266,6 @@ class TelnyxVoicePlatform extends BasePlatform {
     }
   }
 
-  // Play the pre-cached hold phrase (instant) or fall back to Telnyx speak.
   async _playThinkAudio(ccId) {
     if (this._thinkAudioFile) {
       try {
@@ -294,7 +275,6 @@ class TelnyxVoicePlatform extends BasePlatform {
         console.warn(`[TelnyxVoice] Pre-cached think audio failed: ${err.message}`);
       }
     }
-    // Fallback: Telnyx native speak (still fast — no file gen needed)
     try {
       await this._client.calls.actions.speak(ccId, {
         payload:  'One moment please.',
@@ -306,8 +286,6 @@ class TelnyxVoicePlatform extends BasePlatform {
     }
   }
 
-  // ── OpenAI TTS / STT ───────────────────────────────────────────────────────
-
   async _tts(text, destPath) {
     const mp3 = await this._openai.audio.speech.create({
       model: this.ttsModel,
@@ -318,8 +296,6 @@ class TelnyxVoicePlatform extends BasePlatform {
     await fs.promises.writeFile(destPath, buf);
   }
 
-  // Say text on a call — tries OpenAI TTS+hosted audio first, falls back to
-  // Telnyx native speak (no external hosting or OpenAI key required).
   async _sayText(ccId, text) {
     if (this._openai) {
       try {
@@ -333,7 +309,6 @@ class TelnyxVoicePlatform extends BasePlatform {
         console.warn(`[TelnyxVoice] OpenAI TTS failed (${err.message}), falling back to Telnyx speak`);
       }
     }
-    // Telnyx native speak fallback
     try {
       const isGerman = /\b(ich|du|ist|und|der|die|das|nicht|ein|hallo|auf|danke|bitte|wie|was|wer|wo|warum|kann|haben|sein|noch|auch|mit|von|bei|nach|für)\b/i.test(text);
       await this._client.calls.actions.speak(ccId, {
@@ -360,8 +335,6 @@ class TelnyxVoicePlatform extends BasePlatform {
     }
   }
 
-  // ── File helpers ───────────────────────────────────────────────────────────
-
   async _downloadRecording(url, dest) {
     return new Promise((resolve, reject) => {
       const file = fs.createWriteStream(dest);
@@ -384,74 +357,58 @@ class TelnyxVoicePlatform extends BasePlatform {
     return `${prefix}_${ccId.replace(/[^a-zA-Z0-9]/g, '')}_${Date.now()}.mp3`;
   }
 
-  // ── Main webhook handler ───────────────────────────────────────────────────
-  //   Called by MessagingManager.handleTelnyxWebhook() from /api/telnyx/webhook
-
   async handleWebhook(event) {
     if (!event?.data?.event_type) return;
     const { event_type: eventType, payload } = event.data;
     const ccId = payload?.call_control_id;
     if (!ccId) return;
 
-    // Ignore events for sessions we don't know about (except the ones that start one)
     if (!this._hasSession(ccId) &&
         eventType !== 'call.initiated' &&
         eventType !== 'call.answered') {
       return;
     }
 
-    // Outbound call.initiated is handled by initiateCall() already
     if (eventType === 'call.initiated' && payload.direction === 'outbound') return;
 
     console.log(`[TelnyxVoice] ${eventType} — ccId=${ccId.slice(-8)}`);
 
     try {
       switch (eventType) {
-
-        // ── Inbound call received ───────────────────────────────────────────
         case 'call.initiated': {
           if (payload.direction !== 'incoming') break;
           const caller = payload.from;
           if (!this._isAllowed(caller)) {
-            // Check ban list first — banned callers are rejected immediately
             if (this._isBanned(caller)) {
               console.log(`[TelnyxVoice] Rejecting banned caller: ${caller}`);
               await this._rejectCall(ccId);
               this.emit('blocked_caller', { caller, ccId });
               break;
             }
-            // If no secret is configured, fall back to the old reject behaviour
             if (!this.voiceSecret) {
               console.log(`[TelnyxVoice] Blocked non-whitelisted caller (no secret set): ${caller}`);
               await this._rejectCall(ccId);
               this.emit('blocked_caller', { caller, ccId });
               break;
             }
-            // Secret configured — answer and wait silently for code entry
             console.log(`[TelnyxVoice] Non-whitelisted caller ${caller} — awaiting secret code`);
             this._initSession(ccId, caller);
             this._session(ccId).awaitingSecret = true;
             await this._answerCall(ccId);
             break;
           }
-          // Init session BEFORE answering so call.answered (which arrives as a
-          // separate concurrent webhook) always finds a valid session.
           this._initSession(ccId, caller);
           await this._answerCall(ccId);
           console.log(`[TelnyxVoice] Answered inbound call from ${caller}`);
           break;
         }
-
-        // ── Call connected — play greeting ──────────────────────────────────
         case 'call.answered': {
-          // Fallback: if call.initiated raced and session isn't created yet, init now.
           if (!this._hasSession(ccId)) {
             const caller = payload.from || payload.to || ccId;
             this._initSession(ccId, caller);
             console.log(`[TelnyxVoice] call.answered race — session created late for ${ccId.slice(-8)}`);
           }
           const sess = this._session(ccId);
-          // Non-whitelisted caller in secret-code mode — stay silent and start timer
           if (sess.awaitingSecret) {
             this._startSecretTimer(ccId);
             break;
@@ -463,10 +420,7 @@ class TelnyxVoicePlatform extends BasePlatform {
           await this._sayText(ccId, greetText);
           break;
         }
-
-        // ── Playback lifecycle ──────────────────────────────────────────────
         case 'call.playback.started':
-          // Only set isProcessing for audio we care about (not mid-think noise).
           if (this._hasSession(ccId) && !this._session(ccId).isThinking)
             this._session(ccId).isProcessing = true;
           break;
@@ -475,8 +429,6 @@ class TelnyxVoicePlatform extends BasePlatform {
         case 'call.speak.ended': {
           if (!this._hasSession(ccId)) break;
           const sess = this._session(ccId);
-          // While the agent is thinking (think audio looping) or already thinking,
-          // ignore these events — they are from the think-loop audio, not the response.
           if (sess.isThinking) break;
           sess.isProcessing = false;
           if (!sess.awaitingUserInput) break;
@@ -489,30 +441,23 @@ class TelnyxVoicePlatform extends BasePlatform {
           }, 200);
           break;
         }
-
-        // ── DTMF key — secret-code entry or interrupt-and-restart recording ──
         case 'call.dtmf.received': {
           if (!this._hasSession(ccId)) break;
           const sess = this._session(ccId);
-
-          // ── Secret-code gating mode ─────────────────────────────────────────
           if (sess.awaitingSecret) {
             const digit = String(payload.digit ?? payload.dtmf_digit ?? '').trim();
             if (/^[0-9]$/.test(digit)) {
               sess.secretDigits += digit;
-              // Compare once we have enough digits
               if (this.voiceSecret && sess.secretDigits.length >= this.voiceSecret.length) {
                 this._cancelSecretTimer(ccId);
                 if (sess.secretDigits === this.voiceSecret) {
-                  // ── Correct code — transition to normal call flow ──────────
                   console.log(`[TelnyxVoice] Secret accepted for ${ccId.slice(-8)} (${sess.callerNumber})`);
-                  sess.awaitingSecret    = false;
-                  sess.secretDigits      = '';
-                  sess.isProcessing      = true;
+                  sess.awaitingSecret = false;
+                  sess.secretDigits = '';
+                  sess.isProcessing = true;
                   sess.awaitingUserInput = true;
                   await this._sayText(ccId, 'Hello! I am your AI assistant. How can I help you?');
                 } else {
-                  // ── Wrong code — ban and hang up ───────────────────────────
                   console.log(`[TelnyxVoice] Wrong secret from ${sess.callerNumber}, banning`);
                   this._banNumber(sess.callerNumber);
                   this._endSession(ccId);