neoagent 3.2.1-beta.8 → 3.3.0

package/server/routes/behavior.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const express = require('express');
+const { requireAuth } = require('../middleware/auth');
+const {
+  MODULE_IDS,
+  cloneDefaults,
+  getBehaviorConfig,
+  setBehaviorConfig,
+  resolveBehaviorConfig,
+} = require('../services/behavior');
+const {
+  getAgentIdFromRequest,
+  resolveAgentId,
+} = require('../services/agents/manager');
+const { invalidateSystemPromptCache } = require('../services/ai/systemPrompt');
+
+const router = express.Router();
+router.use(requireAuth);
+
+function requestAgentId(req) {
+  return resolveAgentId(req.session.userId, getAgentIdFromRequest(req));
+}
+
+router.get('/', (req, res) => {
+  const userId = req.session.userId;
+  const agentId = requestAgentId(req);
+  res.json({
+    agentId,
+    modules: MODULE_IDS,
+    defaults: cloneDefaults(),
+    config: getBehaviorConfig(userId, agentId),
+  });
+});
+
+router.put('/', (req, res) => {
+  if (!req.body?.config || typeof req.body.config !== 'object' || Array.isArray(req.body.config)) {
+    return res.status(400).json({ error: 'config must be an object' });
+  }
+  const userId = req.session.userId;
+  const agentId = requestAgentId(req);
+  const config = setBehaviorConfig(userId, agentId, req.body.config);
+  invalidateSystemPromptCache(userId, agentId);
+  return res.json({ agentId, config });
+});
+
+router.get('/effective', (req, res) => {
+  const userId = req.session.userId;
+  const agentId = requestAgentId(req);
+  const platform = String(req.query.platform || '').trim();
+  const chatId = String(req.query.chatId || '').trim();
+  if (!platform || !chatId) {
+    return res.status(400).json({ error: 'platform and chatId are required' });
+  }
+  return res.json({
+    agentId,
+    config: resolveBehaviorConfig(userId, agentId, {
+      platform,
+      chatId,
+      isGroup: req.query.isGroup !== 'false',
+    }),
+  });
+});
+
+router.get('/diagnostics', (req, res) => {
+  const userId = req.session.userId;
+  const agentId = requestAgentId(req);
+  const platform = String(req.query.platform || '').trim();
+  const chatId = String(req.query.chatId || '').trim();
+  if (!platform || !chatId) {
+    return res.status(400).json({ error: 'platform and chatId are required' });
+  }
+  const pipeline = req.app?.locals?.behaviorPipeline;
+  if (!pipeline?.getDiagnostics) {
+    return res.status(503).json({ error: 'Behavior runtime is not initialized' });
+  }
+  return res.json(pipeline.getDiagnostics(userId, agentId, platform, chatId));
+});
+
+module.exports = router;

package/server/routes/settings.js

@@ -346,6 +346,10 @@ router.put('/', async (req, res) => {
   });
 
   tx(Object.entries(normalizedBody));
+  if (Object.prototype.hasOwnProperty.call(normalizedBody, 'assistant_behavior_notes')) {
+    const { invalidateSystemPromptCache } = require('../services/ai/systemPrompt');
+    invalidateSystemPromptCache(userId, agentId);
+  }
 
   if (Object.keys(normalizedBody).some((key) => VOICE_SETTING_KEYS.has(key))) {
     const manager = req.app?.locals?.messagingManager;

package/server/services/agents/manager.js

@@ -77,7 +77,7 @@ function ensureMainAgent(userId) {
     userId,
     MAIN_AGENT_SLUG,
     'Main',
-    'Default personal assistant and fallback agent.',
+    'Default personal AI contact and fallback agent.',
     'Handle general requests. Delegate to specialist agents only when their responsibilities clearly match.',
     '',
   );

package/server/services/ai/history.js

@@ -126,7 +126,7 @@ async function summarizeMessages(
   const prompt = [
     {
       role: 'system',
-      content: 'Compress conversation context. Preserve user goals, constraints, preferences, decisions, promised follow-ups, recurring schedules, important facts, tool outcomes, and unresolved issues. Keep concrete details (names, dates, times, statuses) and avoid vague wording. Keep the same personality context. Output plain text only.'
+      content: 'Compress conversation context. Preserve user goals, constraints, preferences, decisions, promised follow-ups, recurring schedules, important facts, tool outcomes, unresolved issues, and any user-stated communication preferences. Keep concrete details (names, dates, times, statuses) and avoid vague wording. Output plain text only.'
     },
     {
       role: 'user',

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

@@ -20,6 +20,10 @@ const { summarizeCapabilityHealth } = require('../capabilityHealth');
 const { shouldAcceptTaskComplete } = require('../completion');
 const { shortenRunId, summarizeForLog } = require('../logFormat');
 const { getProviderForUser } = require('../provider_selector');
+const {
+  recordModelFailure,
+  recordModelSuccess,
+} = require('../model_failure_cache');
 const { runConversation } = require('./conversation_loop');
 const {
   TERMINAL_STATUSES,
@@ -33,6 +37,7 @@ const {
   buildChurnAssessmentPrompt,
   buildCompletionDecisionPrompt,
   enforceTerminalReplyDecision,
+  enforceChurnAssessment,
   normalizeChurnAssessment,
   normalizeCompletionDecision,
   resolveRunGoalContext,
@@ -85,8 +90,8 @@ const {
   normalizeOutgoingMessage,
   clampRunContext,
 } = require('../messagingFallback');
-const { isDeferredWorkReply } = require('../terminal_reply');
 const {
+  assessResearchAdequacy,
   summarizeToolExecutions,
 } = require('../toolEvidence');
 const {
@@ -637,6 +642,82 @@ class AgentEngine {
     });
   }
 
+  async inferStructured({
+    userId,
+    agentId = null,
+    modelId = null,
+    purpose = 'fast',
+    system,
+    prompt,
+    maxTokens = 400,
+    fallback = {},
+    signal = null,
+  }) {
+    const { getFailureFallbackModelId } = require('./conversation_loop');
+    const configuredFallbackId = getAiSettings(userId, agentId).fallback_model_id;
+    const failedModelIds = new Set();
+    let requestedModelId = modelId;
+    let selected = null;
+    let result = null;
+
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      selected = await getProviderForUser(
+        userId,
+        prompt,
+        false,
+        requestedModelId,
+        {
+          agentId,
+          signal,
+          selectionHint: {
+            purpose: purpose === 'general' ? 'general' : 'fast',
+            costMode: purpose === 'fast' ? 'economy' : 'balanced_auto',
+          },
+        },
+      );
+      try {
+        result = await this.requestStructuredJson({
+          provider: selected.provider,
+          providerName: selected.providerName,
+          model: selected.model,
+          messages: system ? [{ role: 'system', content: String(system) }] : [],
+          prompt: String(prompt || ''),
+          maxTokens,
+          normalize: (value) => value,
+          fallback,
+          telemetry: { userId, agentId, signal },
+          phase: 'behavior_inference',
+        });
+        recordModelSuccess(userId, agentId, selected.modelSelectionId);
+        break;
+      } catch (error) {
+        if (isAbortError(error, signal) || signal?.aborted) throw error;
+        recordModelFailure(userId, agentId, selected.modelSelectionId, error);
+        failedModelIds.add(selected.modelSelectionId);
+        if (attempt >= 2) throw error;
+        requestedModelId = await getFailureFallbackModelId(
+          userId,
+          agentId,
+          selected.modelSelectionId,
+          configuredFallbackId,
+          error,
+          signal,
+          failedModelIds,
+        );
+        if (!requestedModelId) throw error;
+      }
+    }
+
+    return {
+      parsed: result.value,
+      raw: result.raw,
+      usage: result.usage,
+      model: selected.model,
+      modelSelectionId: selected.modelSelectionId,
+      providerName: selected.providerName,
+    };
+  }
+
   async requestModelResponse({
     provider,
     providerName,
@@ -793,6 +874,11 @@ class AgentEngine {
   }) {
     const runMeta = options?.runId ? this.getRunMeta(options.runId) : null;
     const goalContext = resolveRunGoalContext(runMeta, analysis, plan);
+    const researchAdequacy = assessResearchAdequacy({
+      analysis,
+      goalContext,
+      toolExecutions,
+    });
     const response = await this.requestStructuredJson({
       provider,
       providerName,
@@ -808,6 +894,8 @@ class AgentEngine {
         lastReply,
         iteration,
         maxIterations,
+        analysis,
+        researchAdequacy,
       }),
       maxTokens: 500,
       normalize: (raw) => normalizeCompletionDecision(raw, 'continue'),
@@ -817,9 +905,15 @@ class AgentEngine {
       phase: 'completion_decision',
     });
     return {
-      decision: enforceTerminalReplyDecision(response.value, lastReply),
+      decision: enforceTerminalReplyDecision(response.value, lastReply, {
+        analysis,
+        goalContext,
+        toolExecutions,
+        researchAdequacy,
+      }),
       usage: response.usage,
       raw: response.raw,
+      researchAdequacy,
     };
   }
 
@@ -905,6 +999,12 @@ class AgentEngine {
         goalContext,
         toolExecutions,
         iteration,
+        analysis,
+        researchAdequacy: assessResearchAdequacy({
+          analysis,
+          goalContext,
+          toolExecutions,
+        }),
       }),
       maxTokens: 200,
       normalize: normalizeChurnAssessment,
@@ -913,9 +1013,20 @@ class AgentEngine {
       telemetry: options,
       phase: 'churn_assessment',
     });
+    const researchAdequacy = assessResearchAdequacy({
+      analysis,
+      goalContext,
+      toolExecutions,
+    });
     return {
-      assessment: response.value,
+      assessment: enforceChurnAssessment(response.value, {
+        analysis,
+        goalContext,
+        toolExecutions,
+        researchAdequacy,
+      }),
       usage: response.usage,
+      researchAdequacy,
     };
   }
 
@@ -942,6 +1053,15 @@ class AgentEngine {
         content: [
           'Return JSON only. Distill the current thread working state. Keep it concise and concrete.',
           'Track summary, open_commitments, unresolved_questions, referenced_entities, and last_verified_facts. Do not invent facts.',
+          options.memoryScope?.scopeType === 'channel'
+            ? [
+                'This is a shared room. Extract only durable room or participant facts that are safe and useful in this room.',
+                'Do not infer or store facts about the authenticated owner from another participant’s message.',
+                options.context?.socialIntelligence?.message?.sender
+                  ? `For facts about the current speaker, use the canonical subject "${options.source}:${options.context.socialIntelligence.message.sender}".`
+                  : '',
+              ].filter(Boolean).join(' ')
+            : '',
           buildMemoryConsolidationInstructions(new Date().toISOString()),
           'Schema:',
           JSON.stringify({
@@ -1018,6 +1138,14 @@ class AgentEngine {
           agentId: options.agentId || null,
           conversationId,
           runId,
+          scope: options.memoryScope || undefined,
+          metadata: options.memoryScope
+            ? {
+                trustLevel: 'shared_room_conversation',
+                platform: options.source || null,
+                chatId: options.chatId || null,
+              }
+            : undefined,
           signal: options.signal,
         },
       );
@@ -1214,21 +1342,6 @@ class AgentEngine {
     return options.reasoningEffort || process.env.REASONING_EFFORT || 'low';
   }
 
-  shouldFastCompleteVoiceReply({
-    options = {},
-    toolExecutions = [],
-    failedStepCount = 0,
-    messagingSent = false,
-    lastReply = '',
-  }) {
-    return options.latencyProfile === 'voice'
-      && toolExecutions.length === 0
-      && failedStepCount === 0
-      && !messagingSent
-      && Boolean(String(lastReply || '').trim())
-      && !isDeferredWorkReply(lastReply);
-  }
-
   getMessagingRetryLimit(maxIterations) {
     // Cap at 3: more than 3 autonomous messaging retries indicates a structural
     // problem (model unavailable, bad config) that more retries won't solve.

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

@@ -33,9 +33,9 @@ function shouldContinueAfterRecoverableToolFailure({
   if (Number(remainingIterations || 0) <= 0) return false;
   const failedExecution = latestFailedToolExecution(toolExecutions);
   if (!isRecoverableInternalToolFailure(failedExecution)) return false;
-  const visible = normalizeOutgoingMessage(lastContent || '');
-  if (!visible) return false;
-  return /\b(blocked|could not|cannot|can't|do not have a confirmed finished result|not found|missing|internal tool issue)\b/i.test(visible);
+  // Structural only: recoverable internal tool failure + remaining budget.
+  // Do not phrase-match the draft reply.
+  return Boolean(normalizeOutgoingMessage(lastContent || '') || failedExecution);
 }
 
 function buildBlankAfterToolFailureGuidance(toolExecutions = []) {
@@ -46,7 +46,8 @@ function buildBlankAfterToolFailureGuidance(toolExecutions = []) {
   return [
     `The previous tool "${toolName}" failed with: ${summarizeForLog(failure, 240)}.`,
     'The latest assistant turn returned no user-facing answer and no tool call, so the task is not terminal.',
-    'Continue with the next safe recovery action: retry with corrected arguments, use another available tool, verify from existing evidence, or report a real blocker only if no autonomous path remains.',
+    'Continue with the next safe recovery action now in this same turn: retry with corrected arguments, use another available tool, verify from existing evidence, or report a real blocker only if no autonomous path remains.',
+    'Do not invent a finished result. Prefer a concrete recovery step or a truthful partial answer over silence.',
   ].join(' ');
 }