neoagent 2.0.6 → 2.0.8

package/server/routes/recordings.js

@@ -110,4 +110,24 @@ router.post('/:sessionId/retry', async (req, res) => {
   }
 });
 
+router.delete('/:sessionId/segments/:segmentId', (req, res) => {
+  try {
+    const manager = req.app.locals.recordingManager;
+    const session = manager.deleteTranscriptSegment(
+      req.session.userId,
+      req.params.sessionId,
+      req.params.segmentId,
+    );
+    res.json({ session });
+  } catch (err) {
+    const message = sanitizeError(err);
+    const status = /not found/i.test(message)
+      ? 404
+      : /positive integer/i.test(message)
+        ? 400
+        : 500;
+    res.status(status).json({ error: message });
+  }
+});
+
 module.exports = router;

package/server/routes/scheduler.js

@@ -14,13 +14,13 @@ router.get('/', (req, res) => {
 // Create a new scheduled task
 router.post('/', (req, res) => {
   try {
-    const { name, cronExpression, prompt, enabled } = req.body;
+    const { name, cronExpression, prompt, enabled, model } = req.body;
     if (!name || !cronExpression || !prompt) {
       return res.status(400).json({ error: 'name, cronExpression, and prompt required' });
     }
 
     const scheduler = req.app.locals.scheduler;
-    const task = scheduler.createTask(req.session.userId, { name, cronExpression, prompt, enabled });
+    const task = scheduler.createTask(req.session.userId, { name, cronExpression, prompt, enabled, model });
     res.status(201).json(task);
   } catch (err) {
     res.status(400).json({ error: sanitizeError(err) });

package/server/routes/settings.js

@@ -1,5 +1,6 @@
 const express = require('express');
 const fs = require('fs');
+const path = require('path');
 const router = express.Router();
 const db = require('../db/database');
 const { requireAuth } = require('../middleware/auth');
@@ -28,6 +29,17 @@ function readUpdateStatus() {
   }
 }
 
+function writeUpdateStatus(patch) {
+  const next = {
+    ...readUpdateStatus(),
+    ...patch,
+    updatedAt: new Date().toISOString()
+  };
+  fs.mkdirSync(path.dirname(UPDATE_STATUS_FILE), { recursive: true });
+  fs.writeFileSync(UPDATE_STATUS_FILE, JSON.stringify(next, null, 2));
+  return next;
+}
+
 // Get supported models metadata
 router.get('/meta/models', async (req, res) => {
   const { getSupportedModels } = require('../services/ai/models');
@@ -221,6 +233,16 @@ router.post('/update', (req, res) => {
     return res.status(409).json({ success: false, error: 'An update is already running' });
   }
   console.log('[Settings] Triggering update-runner...');
+  writeUpdateStatus({
+    state: 'running',
+    progress: 1,
+    phase: 'starting',
+    message: 'Launching update job',
+    startedAt: new Date().toISOString(),
+    completedAt: null,
+    changelog: [],
+    logs: []
+  });
 
   // Spawn detached runner so status survives server restarts.
   const child = spawn(process.execPath, ['scripts/update-runner.js'], {
@@ -229,6 +251,16 @@ router.post('/update', (req, res) => {
     cwd: APP_DIR
   });
 
+  child.once('error', (error) => {
+    writeUpdateStatus({
+      state: 'failed',
+      progress: 100,
+      phase: 'failed',
+      message: `Failed to launch update job: ${error.message}`,
+      completedAt: new Date().toISOString()
+    });
+  });
+
   child.unref();
   res.json({ success: true, message: 'Update triggered', pid: child.pid });
 });

package/server/services/ai/tools.js

@@ -437,6 +437,7 @@ function getAvailableTools(app, options = {}) {
                     cron_expression: { type: 'string', description: 'Cron expression for the schedule, e.g. "0 9 * * 1-5" for weekdays at 9am, "*/30 * * * *" for every 30 minutes. Use standard 5-field cron syntax.' },
                     prompt: { type: 'string', description: 'The prompt/instructions the agent will run when triggered. Be specific about what to do and who to notify.' },
                     enabled: { type: 'boolean', description: 'Whether to activate immediately (default true)' },
+                    model: { type: 'string', description: 'Optional specific AI model ID to force for this task. Omit to use the normal automatic/default model selection.' },
                     call_to: { type: 'string', description: 'E.164 phone number to call via Telnyx when this task fires, e.g. "+12125550100".' },
                     call_greeting: { type: 'string', description: 'Opening sentence spoken to the user when the call is answered. Required if call_to is set.' }
                 },
@@ -452,6 +453,7 @@ function getAvailableTools(app, options = {}) {
                     name: { type: 'string', description: 'Short descriptive name, e.g. "Remind about meeting"' },
                     run_at: { type: 'string', description: 'ISO 8601 datetime when the run should fire, e.g. "2026-03-09T22:00:00"' },
                     prompt: { type: 'string', description: 'The prompt/instructions the agent will execute at that time. Be specific.' },
+                    model: { type: 'string', description: 'Optional specific AI model ID to force for this run. Omit to use the normal automatic/default model selection.' },
                     call_to: { type: 'string', description: 'Optional E.164 phone number to call via Telnyx when this fires.' },
                     call_greeting: { type: 'string', description: 'Opening sentence spoken when the Telnyx call is answered.' }
                 },
@@ -485,6 +487,7 @@ function getAvailableTools(app, options = {}) {
                     cron_expression: { type: 'string', description: 'New cron expression, e.g. "0 8 * * *" for daily at 8am' },
                     prompt: { type: 'string', description: 'New prompt/instructions for the task' },
                     enabled: { type: 'boolean', description: 'Enable or disable the task' },
+                    model: { type: 'string', description: 'Specific AI model ID for this task. Set to empty string to clear the override and go back to automatic/default selection.' },
                     call_to: { type: 'string', description: 'E.164 phone number to call via Telnyx when this task fires. Set to empty string to remove.' },
                     call_greeting: { type: 'string', description: 'New opening sentence spoken when the Telnyx call is answered.' }
                 },
@@ -997,6 +1000,7 @@ async function executeTool(toolName, args, context, engine) {
                     cronExpression: args.cron_expression,
                     prompt: args.prompt,
                     enabled: args.enabled !== false,
+                    model: args.model || null,
                     callTo: args.call_to || null,
                     callGreeting: args.call_greeting || null
                 });
@@ -1016,6 +1020,7 @@ async function executeTool(toolName, args, context, engine) {
                     prompt: args.prompt,
                     runAt: args.run_at,
                     oneTime: true,
+                    model: args.model || null,
                     callTo: args.call_to || null,
                     callGreeting: args.call_greeting || null
                 });
@@ -1052,6 +1057,7 @@ async function executeTool(toolName, args, context, engine) {
                 if (args.cron_expression !== undefined) updates.cronExpression = args.cron_expression;
                 if (args.prompt !== undefined) updates.prompt = args.prompt;
                 if (args.enabled !== undefined) updates.enabled = args.enabled;
+                if (args.model !== undefined) updates.model = args.model || null;
                 if (args.call_to !== undefined) updates.callTo = args.call_to || null;
                 if (args.call_greeting !== undefined) updates.callGreeting = args.call_greeting || null;
                 const updated = s.updateTask(args.task_id, userId, updates);

package/server/services/recordings/manager.js

@@ -441,9 +441,7 @@ class RecordingManager {
         }
       })();
 
-      const transcriptText = ordered
-        .map((segment) => `[${this.#formatTimestamp(segment.startMs)}] ${segment.text}`)
-        .join('\n');
+      const transcriptText = this.#composeTranscriptText(ordered);
       db.prepare(`
         UPDATE recording_sessions
         SET
@@ -490,6 +488,57 @@ class RecordingManager {
     return this.getSession(userId, sessionId);
   }
 
+  deleteTranscriptSegment(userId, sessionId, segmentId) {
+    const session = db.prepare(`
+      SELECT id
+      FROM recording_sessions
+      WHERE id = ? AND user_id = ?
+    `).get(sessionId, userId);
+    if (!session) {
+      throw new Error('Recording session not found.');
+    }
+
+    const normalizedSegmentId = Number(segmentId);
+    if (!Number.isInteger(normalizedSegmentId) || normalizedSegmentId <= 0) {
+      throw new Error('segmentId must be a positive integer.');
+    }
+
+    const segment = db.prepare(`
+      SELECT id
+      FROM recording_transcript_segments
+      WHERE session_id = ? AND id = ?
+    `).get(sessionId, normalizedSegmentId);
+    if (!segment) {
+      throw new Error('Transcript segment not found.');
+    }
+
+    const now = new Date().toISOString();
+    let transcriptText = '';
+    db.transaction(() => {
+      db.prepare(`
+        DELETE FROM recording_transcript_segments
+        WHERE session_id = ? AND id = ?
+      `).run(sessionId, normalizedSegmentId);
+
+      const remainingSegments = db.prepare(`
+        SELECT start_ms, text
+        FROM recording_transcript_segments
+        WHERE session_id = ?
+        ORDER BY start_ms ASC, id ASC
+      `).all(sessionId);
+      transcriptText = this.#composeTranscriptText(remainingSegments);
+
+      db.prepare(`
+        UPDATE recording_sessions
+        SET transcript_text = ?, updated_at = ?
+        WHERE id = ?
+      `).run(transcriptText, now, sessionId);
+    })();
+
+    this.#emitUpdate(userId, sessionId);
+    return this.getSession(userId, sessionId);
+  }
+
   async #transcribeSourceChunks(source, chunks) {
     const segments = [];
 
@@ -677,6 +726,20 @@ class RecordingManager {
     };
   }
 
+  #composeTranscriptText(segments) {
+    return (Array.isArray(segments) ? segments : [])
+      .map((segment) => {
+        const startMs = Number(segment.startMs ?? segment.start_ms) || 0;
+        const text = `${segment.text || ''}`.trim();
+        if (!text) {
+          return null;
+        }
+        return `[${this.#formatTimestamp(startMs)}] ${text}`;
+      })
+      .filter((line) => line != null)
+      .join('\n');
+  }
+
   #emitUpdate(userId, sessionId) {
     this.io?.to?.(`user:${userId}`)?.emit('recordings:updated', { sessionId });
   }

package/server/services/scheduler/cron.js

@@ -108,7 +108,7 @@ class Scheduler {
     }
   }
 
-  createTask(userId, { name, cronExpression, prompt, enabled = true, callTo = null, callGreeting = null, runAt = null, oneTime = false }) {
+  createTask(userId, { name, cronExpression, prompt, enabled = true, callTo = null, callGreeting = null, model = null, runAt = null, oneTime = false }) {
     if (oneTime) {
       if (!runAt) throw new Error('runAt is required for one-time tasks');
       const runAtDate = new Date(runAt);
@@ -116,12 +116,13 @@ class Scheduler {
 
       const config = { prompt };
       if (callTo) { config.callTo = callTo; config.callGreeting = callGreeting || ''; }
+      if (typeof model === 'string' && model.trim()) config.model = model.trim();
 
       const result = db.prepare(
         'INSERT INTO scheduled_tasks (user_id, name, cron_expression, run_at, one_time, task_type, task_config, enabled) VALUES (?, ?, NULL, ?, 1, ?, ?, ?)'
       ).run(userId, name, runAtDate.toISOString().replace('T', ' ').replace(/\.\d{3}Z$/, ''), 'agent_prompt', JSON.stringify(config), enabled ? 1 : 0);
 
-      return { id: result.lastInsertRowid, name, runAt: runAtDate.toISOString(), oneTime: true, enabled };
+      return { id: result.lastInsertRowid, name, runAt: runAtDate.toISOString(), oneTime: true, enabled, model: config.model || null };
     }
 
     if (!cronExpression || !cron.validate(cronExpression)) {
@@ -130,6 +131,7 @@ class Scheduler {
 
     const config = { prompt };
     if (callTo) { config.callTo = callTo; config.callGreeting = callGreeting || ''; }
+    if (typeof model === 'string' && model.trim()) config.model = model.trim();
 
     const result = db.prepare(
       'INSERT INTO scheduled_tasks (user_id, name, cron_expression, task_type, task_config, enabled) VALUES (?, ?, ?, ?, ?, ?)'
@@ -141,7 +143,7 @@ class Scheduler {
       this._scheduleTask(taskId, userId, cronExpression, config);
     }
 
-    return { id: taskId, name, cronExpression, enabled, callTo: config.callTo || null };
+    return { id: taskId, name, cronExpression, enabled, callTo: config.callTo || null, model: config.model || null };
   }
 
   updateTask(taskId, userId, updates) {
@@ -157,6 +159,13 @@ class Scheduler {
     if (updates.prompt !== undefined) config.prompt = updates.prompt;
     if (updates.callTo !== undefined) config.callTo = updates.callTo || null;
     if (updates.callGreeting !== undefined) config.callGreeting = updates.callGreeting || null;
+    if (updates.model !== undefined) {
+      if (typeof updates.model === 'string' && updates.model.trim()) {
+        config.model = updates.model.trim();
+      } else {
+        delete config.model;
+      }
+    }
     // Clean up nulls
     if (!config.callTo) { delete config.callTo; delete config.callGreeting; }
 
@@ -178,7 +187,7 @@ class Scheduler {
       this._scheduleTask(taskId, userId, cronExpr, config);
     }
 
-    return { id: taskId, name, cronExpression: cronExpr, enabled, callTo: config.callTo || null };
+    return { id: taskId, name, cronExpression: cronExpr, enabled, callTo: config.callTo || null, model: config.model || null };
   }
 
   deleteTask(taskId, userId) {
@@ -197,17 +206,21 @@ class Scheduler {
 
   listTasks(userId) {
     const tasks = db.prepare('SELECT * FROM scheduled_tasks WHERE user_id = ? ORDER BY created_at DESC').all(userId);
-    return tasks.map(t => ({
-      id: t.id,
-      name: t.name,
-      cronExpression: t.cron_expression,
-      runAt: t.run_at || null,
-      oneTime: !!t.one_time,
-      enabled: !!t.enabled,
-      lastRun: t.last_run,
-      nextRun: t.one_time ? t.run_at : this._getNextRun(t.cron_expression),
-      config: JSON.parse(t.task_config || '{}')
-    }));
+    return tasks.map(t => {
+      const config = JSON.parse(t.task_config || '{}');
+      return {
+        id: t.id,
+        name: t.name,
+        cronExpression: t.cron_expression,
+        runAt: t.run_at || null,
+        oneTime: !!t.one_time,
+        enabled: !!t.enabled,
+        lastRun: t.last_run,
+        nextRun: t.one_time ? t.run_at : this._getNextRun(t.cron_expression),
+        config,
+        model: config.model || null
+      };
+    });
   }
 
   runTaskNow(taskId, userId) {
@@ -248,13 +261,16 @@ class Scheduler {
 
         const convId = this._getMessagingConversation(userId);
 
-        const result = await this.agentEngine.run(userId, config.prompt + notifyHint, {
+        const runOptions = {
           triggerType: 'scheduler',
           triggerSource: 'scheduler',
           app: this.app,
           ...(convId ? { conversationId: convId } : {}),
           taskId,
-        });
+        };
+        const result = typeof this.agentEngine.runWithModel === 'function'
+          ? await this.agentEngine.runWithModel(userId, config.prompt + notifyHint, runOptions, config.model || null)
+          : await this.agentEngine.run(userId, config.prompt + notifyHint, runOptions);
         this.io.to(`user:${userId}`).emit('scheduler:task_complete', { taskId, result });
       }
     } catch (err) {