neoagent 2.5.2-beta.8 → 3.0.0

package/server/services/ai/loop/progress_classification.js

@@ -0,0 +1,178 @@
+'use strict';
+
+const READ_ONLY_COMMANDS = new Set([
+  'awk',
+  'base64',
+  'cat',
+  'curl',
+  'diff',
+  'du',
+  'egrep',
+  'env',
+  'fgrep',
+  'find',
+  'git',
+  'grep',
+  'head',
+  'jq',
+  'less',
+  'ls',
+  'pwd',
+  'rg',
+  'sed',
+  'sort',
+  'tail',
+  'tee',
+  'test',
+  'tr',
+  'tree',
+  'wc',
+  'which',
+]);
+
+const GIT_READ_ONLY_SUBCOMMANDS = new Set([
+  'branch',
+  'diff',
+  'grep',
+  'log',
+  'ls-files',
+  'ls-remote',
+  'rev-parse',
+  'show',
+  'status',
+]);
+
+const STATE_CHANGING_COMMANDS = new Set([
+  'apply_patch',
+  'chmod',
+  'chown',
+  'cp',
+  'git-clone',
+  'git-commit',
+  'git-push',
+  'git-switch',
+  'git-checkout',
+  'git-merge',
+  'git-rebase',
+  'install',
+  'mkdir',
+  'mv',
+  'npm',
+  'pnpm',
+  'rm',
+  'rmdir',
+  'touch',
+  'yarn',
+]);
+
+function stripShellNoise(command = '') {
+  return String(command || '')
+    .replace(/(^|\n)\s*#.*(?=\n|$)/g, '\n')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function firstToken(segment = '') {
+  const match = String(segment || '').trim().match(/^([A-Za-z0-9_./-]+)/);
+  return match ? match[1] : '';
+}
+
+function normalizeCommandName(token = '') {
+  return String(token || '').trim().split('/').pop().toLowerCase();
+}
+
+function splitCommandSegments(command = '') {
+  return stripShellNoise(command)
+    .split(/\s*(?:&&|\|\||;|\||\n)\s*/g)
+    .map((segment) => segment.trim())
+    .filter(Boolean);
+}
+
+function stripEnvAssignments(segment = '') {
+  let text = String(segment || '').trim();
+  while (/^[A-Za-z_][A-Za-z0-9_]*=/.test(text)) {
+    text = text.replace(/^[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|\S+)\s*/, '').trim();
+  }
+  return text;
+}
+
+function gitSubcommand(segment = '') {
+  const parts = stripEnvAssignments(segment).split(/\s+/).filter(Boolean);
+  if (normalizeCommandName(parts[0]) !== 'git') return '';
+  return String(parts[1] || '').toLowerCase();
+}
+
+function isReadOnlyGitCommand(segment = '') {
+  const subcommand = gitSubcommand(segment);
+  if (!subcommand) return false;
+  return GIT_READ_ONLY_SUBCOMMANDS.has(subcommand);
+}
+
+function isReadOnlyInterpreterCommand(segment = '') {
+  const normalized = stripEnvAssignments(segment);
+  const commandName = normalizeCommandName(firstToken(normalized));
+  if (!['node', 'perl', 'python', 'python3'].includes(commandName)) return false;
+  if (/\b(open|write|writefile|appendfile|unlink|rename|mkdir|rmdir|remove|rm|spawn|exec)\b/i.test(normalized)) {
+    return false;
+  }
+  return /\b(print|json\.|json_tool|json\.load|json\.loads|sys\.stdin|process\.exit|console\.log)\b|-m\s+json\.tool/i.test(normalized);
+}
+
+function hasStateChangingRedirect(segment = '') {
+  const matches = String(segment || '').matchAll(/(?:^|[^&|;])(?:>>?|1>)\s*(?:"([^"]+)"|'([^']+)'|(\S+))/g);
+  for (const match of matches) {
+    const target = String(match[1] || match[2] || match[3] || '').trim();
+    if (!target || target === '/dev/null') continue;
+    if (target.startsWith('/tmp/') || target.startsWith('/var/tmp/')) continue;
+    return true;
+  }
+  return false;
+}
+
+function isStateChangingShellSegment(segment = '') {
+  const normalized = stripEnvAssignments(segment);
+  if (hasStateChangingRedirect(normalized)) return true;
+  const command = normalizeCommandName(firstToken(normalized));
+  if (!command) return false;
+  if (command === 'git') {
+    const subcommand = gitSubcommand(normalized);
+    return subcommand && !GIT_READ_ONLY_SUBCOMMANDS.has(subcommand);
+  }
+  return STATE_CHANGING_COMMANDS.has(command);
+}
+
+function isClearlyReadOnlyShellCommand(command = '') {
+  const segments = splitCommandSegments(command);
+  if (segments.length === 0) return false;
+  return segments.every((segment) => {
+    const normalized = stripEnvAssignments(segment);
+    if (isStateChangingShellSegment(normalized)) return false;
+    if (isReadOnlyGitCommand(normalized)) return true;
+    if (isReadOnlyInterpreterCommand(normalized)) return true;
+    const commandName = normalizeCommandName(firstToken(normalized));
+    if (!commandName) return false;
+    return READ_ONLY_COMMANDS.has(commandName);
+  });
+}
+
+function isProgressToolCall(toolName, toolArgs = {}) {
+  const name = String(toolName || '');
+  if (!name) return false;
+  if (name === 'activate_tools' || name === 'save_widget_snapshot') return false;
+  if (name === 'send_interim_update') return false;
+  if (/^(list_|search_|read_file|get_file|find_files?|github_list|github_get|github_search|browser_get|browser_read)/.test(name)) {
+    return false;
+  }
+  if (name === 'http_request' || name === 'github_api_request') {
+    return String(toolArgs?.method || 'GET').toUpperCase() !== 'GET';
+  }
+  if (name === 'execute_command') {
+    return !isClearlyReadOnlyShellCommand(toolArgs?.command || '');
+  }
+  return true;
+}
+
+module.exports = {
+  isClearlyReadOnlyShellCommand,
+  isProgressToolCall,
+};

package/server/services/ai/loop/progress_monitor.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const FIRST_UPDATE_MS = 30 * 1000;
+const REPEAT_UPDATE_MS = 75 * 1000;
+const STALL_MS = 150 * 1000;
+const TICK_MS = 15 * 1000;
+
+function isoNow() {
+  return new Date().toISOString();
+}
+
+function timestampMs(value, fallback = 0) {
+  const resolved = value ? Date.parse(value) : NaN;
+  return Number.isFinite(resolved) ? resolved : fallback;
+}
+
+function buildInitialProgressLedger({ startedAt, retryState = {} } = {}) {
+  const startedAtIso = startedAt || isoNow();
+  const interimHistory = Array.isArray(retryState.interimHistory)
+    ? retryState.interimHistory
+      .map((item) => String(item?.content || '').trim())
+      .filter(Boolean)
+    : [];
+  const lastInterimMessage = interimHistory[interimHistory.length - 1] || '';
+  const lastVisibleAt = retryState.lastUserVisibleUpdateAt || (lastInterimMessage ? startedAtIso : null);
+  return {
+    currentStep: retryState.currentStep || null,
+    currentTool: retryState.currentTool || null,
+    currentStepStartedAt: retryState.currentStepStartedAt || null,
+    lastVerifiedProgressAt: retryState.lastVerifiedProgressAt || startedAtIso,
+    lastUserVisibleUpdateAt: lastVisibleAt,
+    lastFinalDeliveryAt: retryState.lastFinalDeliveryAt || null,
+    heartbeatCount: Number(retryState.heartbeatCount || 0),
+    stallNotifiedAt: retryState.stallNotifiedAt || null,
+    progressState: retryState.progressState || 'active',
+    currentPhase: retryState.currentPhase || 'idle',
+  };
+}
+
+function evaluateProgressLiveness(runMeta, now = Date.now()) {
+  const startedAtMs = Number.isFinite(runMeta?.startedAt) ? runMeta.startedAt : now;
+  const ledger = runMeta?.progressLedger || {};
+  const lastVerifiedAtMs = timestampMs(ledger.lastVerifiedProgressAt, startedAtMs);
+  const lastVisibleAtMs = timestampMs(ledger.lastUserVisibleUpdateAt, 0);
+  const thresholdMs = lastVisibleAtMs > 0 ? REPEAT_UPDATE_MS : FIRST_UPDATE_MS;
+  const comparisonVisibleAtMs = lastVisibleAtMs > 0 ? lastVisibleAtMs : startedAtMs;
+  const shouldNudge = (now - comparisonVisibleAtMs) >= thresholdMs;
+  const stalled = (now - lastVerifiedAtMs) >= STALL_MS;
+
+  return {
+    startedAtMs,
+    thresholdMs,
+    shouldNudge,
+    stalled,
+    phase: ledger.currentPhase || 'idle',
+    currentStep: ledger.currentStep || null,
+    currentTool: ledger.currentTool || null,
+  };
+}
+
+function buildProgressNudge({ stalled = false } = {}) {
+  return [
+    'Mandatory internal progress check for the active messaging run.',
+    stalled
+      ? 'No verified progress has been recorded for the stall threshold.'
+      : 'The originating chat has not received a user-visible update for the progress threshold.',
+    'Before starting more tool work, either send a concise model-authored interim update with send_interim_update, report a real blocker, or finish with the final answer.',
+    'Do not continue silently once this check is present unless the immediate next action itself delivers a final answer or explicit no-response decision.',
+    'Do not repeat previous status text and do not treat an interim update as final delivery.',
+  ].join(' ');
+}
+
+module.exports = {
+  FIRST_UPDATE_MS,
+  REPEAT_UPDATE_MS,
+  STALL_MS,
+  TICK_MS,
+  buildInitialProgressLedger,
+  evaluateProgressLiveness,
+  buildProgressNudge,
+};

package/server/services/ai/loop/run_state.js

@@ -0,0 +1,356 @@
+'use strict';
+
+const { v4: uuidv4 } = require('uuid');
+const db = require('../../../db/database');
+const { activateTools } = require('../toolSelector');
+const { recordRunEvent } = require('../runEvents');
+const { parseMaybeJson } = require('../logFormat');
+const { mergeGoalContracts } = require('./completion_judge');
+const { buildInitialProgressLedger } = require('./progress_monitor');
+const {
+  createDeliveryState,
+  markInterimDelivered,
+  markFinalDelivered,
+} = require('./delivery_state');
+
+function isoNow() {
+  return new Date().toISOString();
+}
+
+function persistRunMetadata(_engine, runId, patch = {}) {
+  if (!runId || !patch || typeof patch !== 'object') return;
+  const existing = db.prepare('SELECT metadata_json FROM agent_runs WHERE id = ?').get(runId);
+  const current = parseMaybeJson(existing?.metadata_json, {}) || {};
+  const next = { ...current, ...patch };
+  db.prepare('UPDATE agent_runs SET metadata_json = ? WHERE id = ?')
+    .run(JSON.stringify(next), runId);
+}
+
+function updateRunGoalContract(engine, runId, patch = {}, options = {}) {
+  const runMeta = engine.getRunMeta(runId);
+  if (!runMeta) return null;
+  runMeta.goalContract = mergeGoalContracts(runMeta.goalContract, patch);
+  if (options.persist !== false) {
+    persistRunMetadata(engine, runId, {
+      goalContract: runMeta.goalContract,
+    });
+  }
+  return runMeta.goalContract;
+}
+
+function buildProgressLedgerSnapshot(_engine, runMeta) {
+  if (!runMeta?.progressLedger) return null;
+  return {
+    currentStep: runMeta.progressLedger.currentStep || null,
+    currentTool: runMeta.progressLedger.currentTool || null,
+    currentStepStartedAt: runMeta.progressLedger.currentStepStartedAt || null,
+    lastVerifiedProgressAt: runMeta.progressLedger.lastVerifiedProgressAt || null,
+    lastUserVisibleUpdateAt: runMeta.progressLedger.lastUserVisibleUpdateAt || null,
+    lastFinalDeliveryAt: runMeta.progressLedger.lastFinalDeliveryAt || null,
+    heartbeatCount: Number(runMeta.progressLedger.heartbeatCount || 0),
+    stallNotifiedAt: runMeta.progressLedger.stallNotifiedAt || null,
+    progressState: runMeta.progressLedger.progressState || 'active',
+    currentPhase: runMeta.progressLedger.currentPhase || 'idle',
+  };
+}
+
+function persistProgressLedger(engine, runId) {
+  const runMeta = engine.getRunMeta(runId);
+  if (!runMeta?.progressLedger) return;
+  persistRunMetadata(engine, runId, {
+    progressLedger: buildProgressLedgerSnapshot(engine, runMeta),
+  });
+}
+
+function updateRunProgress(engine, runId, patch = {}, options = {}) {
+  const runMeta = engine.getRunMeta(runId);
+  if (!runMeta) return null;
+  if (!runMeta.progressLedger) {
+    runMeta.progressLedger = buildInitialProgressLedger({
+      startedAt: runMeta.startedAtIso || isoNow(),
+    });
+  }
+
+  const previousState = runMeta.progressLedger.progressState || 'active';
+  runMeta.progressLedger = {
+    ...runMeta.progressLedger,
+    ...patch,
+  };
+
+  if (options.verified === true) {
+    runMeta.progressLedger.lastVerifiedProgressAt = options.timestamp || isoNow();
+    runMeta.progressLedger.progressState = 'active';
+    runMeta.progressLedger.stallNotifiedAt = null;
+    recordRunEventSafe(engine, runMeta.userId, runId, 'progress_verified', {
+      phase: runMeta.progressLedger.currentPhase || 'idle',
+      currentStep: runMeta.progressLedger.currentStep || null,
+      currentTool: runMeta.progressLedger.currentTool || null,
+    }, { agentId: runMeta.agentId, stepId: options.stepId || null });
+    if (previousState === 'stalled') {
+      recordRunEventSafe(engine, runMeta.userId, runId, 'progress_resumed', {
+        phase: runMeta.progressLedger.currentPhase || 'idle',
+        currentStep: runMeta.progressLedger.currentStep || null,
+        currentTool: runMeta.progressLedger.currentTool || null,
+      }, { agentId: runMeta.agentId, stepId: options.stepId || null });
+    }
+  }
+
+  if (options.persist !== false) {
+    persistProgressLedger(engine, runId);
+  }
+  return runMeta.progressLedger;
+}
+
+function markRunVisibleProgress(engine, runId, timestamp = isoNow()) {
+  const runMeta = engine.getRunMeta(runId);
+  if (!runMeta) return null;
+  if (!runMeta.deliveryState) runMeta.deliveryState = createDeliveryState();
+  markInterimDelivered(runMeta.deliveryState);
+  const ledger = updateRunProgress(engine, runId, {
+    lastUserVisibleUpdateAt: timestamp,
+  }, {
+    persist: false,
+  });
+  persistProgressLedger(engine, runId);
+  return ledger;
+}
+
+function markRunFinalDelivery(engine, runId, content = '', timestamp = isoNow()) {
+  const runMeta = engine.getRunMeta(runId);
+  if (!runMeta) return null;
+  if (!runMeta.deliveryState) runMeta.deliveryState = createDeliveryState();
+  markFinalDelivered(runMeta.deliveryState);
+  runMeta.messagingSent = true;
+  runMeta.finalDeliverySent = true;
+  runMeta.lastSentMessage = String(content || '').trim() || runMeta.lastSentMessage || '';
+  const ledger = updateRunProgress(engine, runId, {
+    lastUserVisibleUpdateAt: timestamp,
+    lastFinalDeliveryAt: timestamp,
+    progressState: 'complete',
+  }, {
+    persist: false,
+  });
+  persistProgressLedger(engine, runId);
+  return ledger;
+}
+
+function recordRunEventSafe(_engine, userId, runId, eventType, payload = {}, options = {}) {
+  try {
+    return recordRunEvent({
+      runId,
+      userId,
+      agentId: options.agentId || null,
+      eventType,
+      requestId: options.requestId || null,
+      stepId: options.stepId || null,
+      payload,
+    });
+  } catch {
+    return null;
+  }
+}
+
+function initializeToolRuntime(engine, runId, allTools, initialTools, options = {}) {
+  const runMeta = engine.getRunMeta(runId);
+  if (!runMeta) return;
+  runMeta.toolCatalog = Array.isArray(allTools) ? allTools : [];
+  runMeta.activeTools = Array.isArray(initialTools) ? initialTools : [];
+  runMeta.toolSelectionOptions = {
+    widgetId: options.widgetId || null,
+  };
+}
+
+function getActiveTools(engine, runId) {
+  return engine.getRunMeta(runId)?.activeTools || [];
+}
+
+function activateToolsForRun(engine, runId, names = []) {
+  const runMeta = engine.getRunMeta(runId);
+  if (!runMeta) throw new Error('Run is not active.');
+  const result = activateTools(
+    runMeta.activeTools,
+    runMeta.toolCatalog,
+    names,
+    runMeta.toolSelectionOptions,
+  );
+  runMeta.activeTools = result.tools;
+  recordRunEventSafe(engine, runMeta.userId, runId, 'tools_activated', {
+    activated: result.activated,
+    evicted: result.evicted,
+    unknown: result.unknown,
+    notActivated: result.notActivated,
+    activeToolNames: result.tools.map((tool) => tool.name),
+  }, { agentId: runMeta.agentId });
+  return {
+    success: result.unknown.length === 0 && result.notActivated.length === 0,
+    activated: result.activated,
+    evicted: result.evicted,
+    unknown: result.unknown,
+    not_activated: result.notActivated,
+    active_tools: result.tools.map((tool) => tool.name),
+  };
+}
+
+function findActiveRunForUser(engine, userId, predicate = null) {
+  let candidate = null;
+  for (const [runId, runMeta] of engine.activeRuns.entries()) {
+    if (runMeta.userId !== userId || runMeta.aborted) continue;
+    if (typeof predicate === 'function' && !predicate(runMeta, runId)) continue;
+    if (!candidate || (runMeta.startedAt || 0) >= (candidate.startedAt || 0)) {
+      candidate = { runId, ...runMeta };
+    }
+  }
+  return candidate;
+}
+
+function findSteerableRunForUser(engine, userId, triggerSource = 'web') {
+  return findActiveRunForUser(
+    engine,
+    userId,
+    (runMeta) => runMeta.triggerSource === triggerSource && runMeta.triggerType === 'user'
+  );
+}
+
+function enqueueSteering(engine, runId, content, metadata = {}) {
+  const runMeta = engine.getRunMeta(runId);
+  const trimmed = typeof content === 'string' ? content.trim() : '';
+  if (!runMeta || runMeta.aborted || !trimmed) return null;
+
+  const item = {
+    id: uuidv4(),
+    content: trimmed,
+    metadata,
+    createdAt: isoNow(),
+  };
+
+  runMeta.steeringQueue.push(item);
+  engine.emit(runMeta.userId, 'run:steer_queued', {
+    runId,
+    content: item.content,
+    pendingCount: runMeta.steeringQueue.length,
+  });
+
+  return {
+    runId,
+    pendingCount: runMeta.steeringQueue.length,
+    item,
+  };
+}
+
+function enqueueSystemSteering(engine, runId, content, metadata = {}) {
+  const runMeta = engine.getRunMeta(runId);
+  const trimmed = typeof content === 'string' ? content.trim() : '';
+  if (!runMeta || runMeta.aborted || !trimmed) return null;
+  if (!Array.isArray(runMeta.systemSteeringQueue)) {
+    runMeta.systemSteeringQueue = [];
+  }
+  const signature = JSON.stringify({
+    content: trimmed,
+    reason: metadata.reason || '',
+  });
+  if (runMeta.systemSteeringQueue.some((item) => item.signature === signature)) {
+    return null;
+  }
+  const item = {
+    id: uuidv4(),
+    content: trimmed,
+    metadata,
+    signature,
+    createdAt: isoNow(),
+  };
+  runMeta.systemSteeringQueue.push(item);
+  return item;
+}
+
+function applyQueuedSystemSteering(engine, runId, messages) {
+  const runMeta = engine.getRunMeta(runId);
+  if (!runMeta?.systemSteeringQueue?.length) {
+    return { messages, appliedCount: 0 };
+  }
+
+  const queued = runMeta.systemSteeringQueue.splice(0, runMeta.systemSteeringQueue.length);
+  for (const entry of queued) {
+    messages.push({ role: 'system', content: entry.content });
+  }
+
+  return { messages, appliedCount: queued.length };
+}
+
+function applyQueuedSteering(engine, runId, messages, { userId, conversationId }) {
+  const runMeta = engine.getRunMeta(runId);
+  if (!runMeta?.steeringQueue?.length) {
+    return { messages, appliedCount: 0 };
+  }
+
+  const queued = runMeta.steeringQueue.splice(0, runMeta.steeringQueue.length);
+  messages.push({
+    role: 'system',
+    content: [
+      'The user sent follow-up messages while you were already working.',
+      'Treat them as steering or next-up context for the same conversation.',
+      'If a message materially changes the active task, incorporate it now.',
+      'If it is unrelated or better handled after the current task, finish the current work first and then address it.',
+    ].join(' '),
+  });
+
+  for (const entry of queued) {
+    messages.push({ role: 'user', content: entry.content });
+    if (conversationId) {
+      db.prepare('INSERT INTO conversation_messages (conversation_id, role, content) VALUES (?, ?, ?)')
+        .run(conversationId, 'user', entry.content);
+    }
+  }
+
+  engine.emit(userId, 'run:steer_applied', {
+    runId,
+    count: queued.length,
+    pendingCount: runMeta.steeringQueue.length,
+    latestContent: queued[queued.length - 1]?.content || '',
+  });
+
+  return { messages, appliedCount: queued.length };
+}
+
+function isRunStopped(engine, runId) {
+  return engine.getRunMeta(runId)?.aborted === true;
+}
+
+function attachProcessToRun(engine, runId, pid) {
+  const runMeta = engine.getRunMeta(runId);
+  if (!runMeta || !pid) return;
+  runMeta.toolPids.add(pid);
+  if (runMeta.aborted) {
+    if (engine.runtimeManager && typeof engine.runtimeManager.killCommand === 'function') {
+      void engine.runtimeManager.killCommand(runMeta.userId, pid, 'aborted');
+    }
+  }
+}
+
+function detachProcessFromRun(engine, runId, pid) {
+  const runMeta = engine.getRunMeta(runId);
+  if (!runMeta || !pid) return;
+  runMeta.toolPids.delete(pid);
+}
+
+module.exports = {
+  activateToolsForRun,
+  applyQueuedSteering,
+  applyQueuedSystemSteering,
+  attachProcessToRun,
+  buildProgressLedgerSnapshot,
+  detachProcessFromRun,
+  enqueueSteering,
+  enqueueSystemSteering,
+  findActiveRunForUser,
+  findSteerableRunForUser,
+  getActiveTools,
+  initializeToolRuntime,
+  isRunStopped,
+  markRunFinalDelivery,
+  markRunVisibleProgress,
+  persistProgressLedger,
+  persistRunMetadata,
+  recordRunEventSafe,
+  updateRunGoalContract,
+  updateRunProgress,
+};