neoagent 2.3.1-beta.98 → 2.4.0

package/server/routes/integrations.js

@@ -89,7 +89,7 @@ router.get('/oauth/callback', async (req, res) => {
             window.opener.postMessage(${payload}, ${trustedOrigin});
             window.close();
           } else {
-            window.location.href = '/';
+            window.close();
           }
         </script>
         <p>Authentication successful. You can close this window.</p>
@@ -116,7 +116,7 @@ router.get('/oauth/callback', async (req, res) => {
           window.opener.postMessage(${payload}, ${trustedOrigin});
           window.close();
         } else {
-          window.location.href = '/?page=skills';
+          window.close();
         }
       </script>
       <p>Authentication successful. You can close this window.</p>

package/server/routes/memory.js

@@ -145,6 +145,79 @@ router.get('/memories', (req, res) => {
   }
 });
 
+router.get('/ingestion/status', (req, res) => {
+  const mm = req.app.locals.memoryManager;
+  const ingestionService = req.app.locals.memoryIngestionService;
+  const userId = req.session.userId;
+  const agentId = resolveAgentId(userId, getAgentIdFromRequest(req));
+  try {
+    res.json({
+      agentId,
+      overview: mm.getIngestionOverview(userId, { agentId }),
+      jobs: mm.listIngestionJobs(userId, { agentId }),
+      recentChanges: mm.listRecentKnowledgeChanges(userId, { agentId }),
+      connections: ingestionService?.listConnectionStatuses?.(userId, { agentId }) || [],
+    });
+  } catch (err) {
+    res.status(500).json({ error: sanitizeError(err) });
+  }
+});
+
+router.post('/ingestion/documents', async (req, res) => {
+  const ingestionService = req.app.locals.memoryIngestionService;
+  const userId = req.session.userId;
+  const agentId = resolveAgentId(userId, getAgentIdFromRequest(req));
+  if (!ingestionService) {
+    return res.status(503).json({ error: 'Memory ingestion service is unavailable.' });
+  }
+  const documents = Array.isArray(req.body?.documents) ? req.body.documents : [];
+  if (!documents.length) {
+    return res.status(400).json({ error: 'documents must contain at least one item.' });
+  }
+  try {
+    const result = await ingestionService.ingestDocuments(userId, documents, {
+      agentId,
+      sourceType: req.body.sourceType,
+      providerKey: req.body.providerKey,
+      connectionId: req.body.connectionId,
+      sourceAccount: req.body.sourceAccount,
+      metadata: normalizeMetadata(req.body.metadata),
+    });
+    res.json(result);
+  } catch (err) {
+    res.status(400).json({ error: sanitizeError(err) });
+  }
+});
+
+router.get('/knowledge-views', (req, res) => {
+  const mm = req.app.locals.memoryManager;
+  const userId = req.session.userId;
+  const agentId = resolveAgentId(userId, getAgentIdFromRequest(req));
+  try {
+    res.json(mm.listKnowledgeViews(userId, {
+      agentId,
+      viewType: req.query.viewType || null,
+      limit: req.query.limit,
+    }));
+  } catch (err) {
+    res.status(500).json({ error: sanitizeError(err) });
+  }
+});
+
+router.post('/knowledge-views/materialize', (req, res) => {
+  const mm = req.app.locals.memoryManager;
+  const userId = req.session.userId;
+  const agentId = resolveAgentId(userId, getAgentIdFromRequest(req));
+  try {
+    res.json({
+      agentId,
+      views: mm.materializeKnowledgeViews(userId, { agentId }),
+    });
+  } catch (err) {
+    res.status(500).json({ error: sanitizeError(err) });
+  }
+});
+
 // Save a new memory
 router.post('/memories', async (req, res) => {
   const mm = req.app.locals.memoryManager;

package/server/services/ai/engine.js

@@ -2,6 +2,7 @@ const { v4: uuidv4 } = require('uuid');
 const fs = require('fs');
 const db = require('../../db/database');
 const { compact } = require('./compaction');
+const { compactPayloadForModel } = require('./preModelCompaction');
 const {
   getConversationContext,
   buildSummaryCarrier,
@@ -1563,6 +1564,37 @@ class AgentEngine {
     let provider = selectedProvider.provider;
     let model = selectedProvider.model;
     let providerName = selectedProvider.providerName;
+    const switchToFallbackModel = async (failedModel, error, phase) => {
+      const fallbackModelId = await getFailureFallbackModelId(userId, agentId, failedModel, aiSettings.fallback_model_id);
+      if (!fallbackModelId || fallbackModelId === failedModel) return false;
+      console.log(`[Engine] ${phase} failed on ${failedModel}; attempting fallback to: ${fallbackModelId}`);
+      this.emit(userId, 'run:interim', {
+        runId,
+        message: `Model service failed on ${failedModel}; retrying with ${fallbackModelId}.`,
+        phase: 'model_fallback'
+      });
+      const fallback = await getProviderForUser(
+        userId,
+        userMessage,
+        triggerType === 'subagent',
+        fallbackModelId,
+        providerStatusConfig
+      );
+      provider = fallback.provider;
+      model = fallback.model;
+      providerName = fallback.providerName;
+      return true;
+    };
+    const runWithModelFallback = async (phase, fn) => {
+      try {
+        return await fn();
+      } catch (err) {
+        const failedModel = model;
+        const switched = await switchToFallbackModel(failedModel, err, phase);
+        if (!switched) throw err;
+        return await fn();
+      }
+    };
 
     const runTitle = generateTitle(userMessage);
     db.prepare(`INSERT OR REPLACE INTO agent_runs(id, user_id, agent_id, title, status, trigger_type, trigger_source, model)
@@ -1683,6 +1715,7 @@ class AgentEngine {
     let modelFailureRecoveries = 0;
     let promptMetrics = {};
     let toolExecutions = [];
+    let compactionMetrics = [];
     let analysis = null;
     let plan = null;
     let verification = null;
@@ -1697,7 +1730,7 @@ class AgentEngine {
       if (options.skipTaskAnalysis === true) {
         analysis = buildSkipTaskAnalysisResult(options.forceMode);
       } else {
-        const analysisResult = await this.analyzeTask({
+        const analysisResult = await runWithModelFallback('task analysis', () => this.analyzeTask({
           provider,
           providerName,
           model,
@@ -1707,7 +1740,7 @@ class AgentEngine {
           forceMode: options.forceMode || null,
           userMessage,
           options: { ...options, triggerSource },
-        });
+        }));
         analysisUsage = analysisResult.usage || 0;
         totalTokens += analysisUsage;
         analysis = applyForcedAnalysisMode({ ...analysisResult.analysis }, options.forceMode);
@@ -1803,7 +1836,7 @@ class AgentEngine {
       }
 
       if (analysis.mode === 'plan_execute') {
-        const planResult = await this.createExecutionPlan({
+        const planResult = await runWithModelFallback('execution planning', () => this.createExecutionPlan({
           provider,
           providerName,
           model,
@@ -1811,7 +1844,7 @@ class AgentEngine {
           analysis,
           capabilitySummary,
           options,
-        });
+        }));
         totalTokens += planResult.usage || 0;
         plan = planResult.plan;
         stepIndex += 1;
@@ -1978,26 +2011,13 @@ class AgentEngine {
           await tryModelCall();
         } catch (err) {
           const modelError = String(err?.message || 'Model call failed');
-          const isFatalModelError = /no ai providers? are currently available|missing an api key|disabled in settings|unauthorized|forbidden|authentication failed/i
-            .test(modelError);
 
-          if (!isFatalModelError && modelFailureRecoveries < loopPolicy.maxModelFailureRecoveries) {
+          if (modelFailureRecoveries < loopPolicy.maxModelFailureRecoveries) {
+            const failedModel = model;
+            const switched = await switchToFallbackModel(failedModel, err, 'model turn');
+            if (!switched) throw err;
             modelFailureRecoveries += 1;
             failedStepCount += 1;
-            const failedModel = model;
-            const fallbackModelId = await getFailureFallbackModelId(userId, agentId, model, aiSettings.fallback_model_id);
-            if (fallbackModelId && fallbackModelId !== model) {
-              const fallback = await getProviderForUser(
-                userId,
-                userMessage,
-                triggerType === 'subagent',
-                fallbackModelId,
-                providerStatusConfig
-              );
-              provider = fallback.provider;
-              model = fallback.model;
-              providerName = fallback.providerName;
-            }
             messages.push({
               role: 'system',
               content: buildModelFailureLoopPrompt({
@@ -2082,7 +2102,7 @@ class AgentEngine {
           }
           if (iteration < maxIterations) {
             const fallbackStatus = (toolExecutions.length > 0 || failedStepCount > 0 || messagingSent) ? 'continue' : 'complete';
-            const loopState = await this.decideLoopState({
+            const loopState = await runWithModelFallback('loop decision', () => this.decideLoopState({
               provider,
               providerName,
               model,
@@ -2098,7 +2118,7 @@ class AgentEngine {
               maxIterations,
               options,
               fallbackStatus,
-            });
+            }));
             totalTokens += loopState.usage || 0;
             if (loopState.decision.status === 'continue') {
               messages.push({
@@ -2278,14 +2298,33 @@ class AgentEngine {
             evidenceSources: [...new Set(toolExecutions.map((item) => item.evidenceSource).filter(Boolean))],
             subagentState: this.listSubagents(runId),
             deliverableArtifacts,
+            compactionMetrics: compactionMetrics.slice(-20),
           });
 
+          const modelPayload = compactPayloadForModel(toolName, toolResult);
+          if (modelPayload.metrics?.applied) {
+            const metric = {
+              toolName,
+              stepId,
+              ...modelPayload.metrics,
+              createdAt: new Date().toISOString(),
+            };
+            compactionMetrics.push(metric);
+            this.persistRunMetadata(runId, {
+              compactionMetrics: compactionMetrics.slice(-20),
+            });
+            this.recordRunEvent(userId, runId, 'pre_model_compaction_applied', {
+              toolName,
+              metrics: modelPayload.metrics,
+            }, { agentId, stepId });
+          }
+
           const toolResultLimits = resolveToolResultLimits(toolName, loopPolicy);
           const toolMessage = {
             role: 'tool',
             name: toolName,
             tool_call_id: toolCall.id,
-            content: compactToolResult(toolName, toolArgs, toolResult, {
+            content: compactToolResult(toolName, toolArgs, modelPayload.result, {
               softLimit: toolResultLimits.softLimit,
               hardLimit: toolResultLimits.hardLimit,
             })
@@ -2456,7 +2495,7 @@ class AgentEngine {
         toolExecutions,
         finalReply: finalResponseText,
       })) {
-        const verificationResult = await this.verifyFinalResponse({
+        const verificationResult = await runWithModelFallback('final verification', () => this.verifyFinalResponse({
           provider,
           providerName,
           model,
@@ -2465,7 +2504,7 @@ class AgentEngine {
           toolExecutions,
           finalReply: finalResponseText,
           options,
-        });
+        }));
         totalTokens += verificationResult.usage || 0;
         verification = verificationResult.verification;
         if (verification.final_reply) {

package/server/services/ai/models.js

@@ -5,6 +5,7 @@ const { OllamaProvider } = require('./providers/ollama');
 const { OpenAIProvider } = require('./providers/openai');
 const { GithubCopilotProvider } = require('./providers/githubCopilot');
 const { OpenAICodexProvider } = require('./providers/openaiCodex');
+const { ClaudeCodeProvider } = require('./providers/claudeCode');
 const {
     AI_PROVIDER_DEFINITIONS,
     getProviderConfigs,
@@ -72,6 +73,24 @@ const STATIC_MODELS = [
         provider: 'anthropic',
         purpose: 'fast'
     },
+    {
+        id: 'claude-opus-4-7',
+        label: 'Claude Opus 4.7 (Claude Code / Default)',
+        provider: 'claude-code',
+        purpose: 'general'
+    },
+    {
+        id: 'claude-sonnet-4-6',
+        label: 'Claude Sonnet 4.6 (Claude Code / Fast)',
+        provider: 'claude-code',
+        purpose: 'coding'
+    },
+    {
+        id: 'claude-haiku-4-5-20251001',
+        label: 'Claude Haiku 4.5 (Claude Code / Subagents)',
+        provider: 'claude-code',
+        purpose: 'fast'
+    },
     {
         id: 'gemini-3.1-flash-lite-preview',
         label: 'Gemini 3.1 Flash Lite (Preview)',
@@ -338,6 +357,8 @@ function createProviderInstance(providerStr, userId = null, configOverrides = {}
         return new GithubCopilotProvider({ apiKey: runtime.apiKey, ...providerOverrides });
     } else if (providerStr === 'openai-codex') {
         return new OpenAICodexProvider({ apiKey: runtime.apiKey, ...providerOverrides });
+    } else if (providerStr === 'claude-code') {
+        return new ClaudeCodeProvider({ apiKey: runtime.apiKey, ...providerOverrides });
     }
     throw new Error(`Unknown provider: ${providerStr}`);
 }

package/server/services/ai/preModelCompaction.js

@@ -0,0 +1,191 @@
+'use strict';
+
+function clampText(value, maxLength = 2000) {
+  const text = String(value || '').trim();
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, Math.max(0, maxLength - 1)).trimEnd()}...`;
+}
+
+function stripHtmlTags(input) {
+  return String(input || '')
+    .replace(/<script[\s\S]*?<\/script>/gi, ' ')
+    .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/&nbsp;/gi, ' ')
+    .replace(/&amp;/gi, '&')
+    .replace(/&lt;/gi, '<')
+    .replace(/&gt;/gi, '>')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function shortenUrlText(input) {
+  return String(input || '').replace(/https?:\/\/[^\s)]+/gi, (match) => {
+    try {
+      const url = new URL(match);
+      const path = url.pathname && url.pathname !== '/' ? clampText(url.pathname, 40) : '';
+      return `${url.hostname}${path}`;
+    } catch {
+      return match;
+    }
+  });
+}
+
+function dedupeLines(input, maxLines = 30) {
+  const seen = new Set();
+  const result = [];
+  for (const rawLine of String(input || '').split('\n')) {
+    const normalized = rawLine.replace(/\s+/g, ' ').trim();
+    if (!normalized) continue;
+    if (seen.has(normalized)) continue;
+    seen.add(normalized);
+    result.push(rawLine.trim());
+    if (result.length >= maxLines) break;
+  }
+  return result.join('\n');
+}
+
+function compactTextPayload(input, options = {}) {
+  const original = String(input || '');
+  let normalized = original;
+  const strategies = [];
+
+  if (/<[a-z!/][^>]*>/i.test(normalized)) {
+    normalized = stripHtmlTags(normalized);
+    strategies.push('html_to_text');
+  }
+
+  const shortenedUrls = shortenUrlText(normalized);
+  if (shortenedUrls !== normalized) {
+    normalized = shortenedUrls;
+    strategies.push('url_shortening');
+  }
+
+  const deduped = dedupeLines(normalized, options.maxLines || 30);
+  if (deduped && deduped !== normalized) {
+    normalized = deduped;
+    strategies.push('line_deduplication');
+  }
+
+  normalized = normalized.replace(/\s+\n/g, '\n').replace(/\n{3,}/g, '\n\n').trim();
+  const finalText = clampText(normalized, options.maxChars || 1800);
+  if (finalText.length < normalized.length) {
+    strategies.push('length_clamp');
+  }
+
+  return {
+    text: finalText,
+    metrics: {
+      inputChars: original.length,
+      outputChars: finalText.length,
+      reducedChars: Math.max(0, original.length - finalText.length),
+      applied: finalText !== original,
+      strategies,
+    },
+  };
+}
+
+function compactHttpResult(result) {
+  const source = result && typeof result === 'object' ? result : {};
+  const compactedBody = compactTextPayload(source.body || '', {
+    maxChars: 2200,
+    maxLines: 40,
+  });
+  return {
+    result: {
+      ...source,
+      body: compactedBody.text,
+    },
+    metrics: compactedBody.metrics,
+  };
+}
+
+function compactExtractResult(result) {
+  const source = result && typeof result === 'object' ? result : {};
+  const content = source.result ?? source.content ?? '';
+  const compacted = compactTextPayload(content, {
+    maxChars: 1800,
+    maxLines: 35,
+  });
+  const next = { ...source };
+  if (Object.prototype.hasOwnProperty.call(next, 'result')) next.result = compacted.text;
+  if (Object.prototype.hasOwnProperty.call(next, 'content')) next.content = compacted.text;
+  if (!Object.prototype.hasOwnProperty.call(next, 'result') && !Object.prototype.hasOwnProperty.call(next, 'content')) {
+    next.result = compacted.text;
+  }
+  return {
+    result: next,
+    metrics: compacted.metrics,
+  };
+}
+
+function compactSearchResult(result) {
+  const source = result && typeof result === 'object' ? result : {};
+  const results = Array.isArray(source.results)
+    ? source.results.slice(0, 8).map((item) => ({
+        ...item,
+        description: clampText(shortenUrlText(item?.description || ''), 220),
+      }))
+    : [];
+  const rawLength = JSON.stringify(source).length;
+  const compactedLength = JSON.stringify({ ...source, results }).length;
+  return {
+    result: {
+      ...source,
+      results,
+    },
+    metrics: {
+      inputChars: rawLength,
+      outputChars: compactedLength,
+      reducedChars: Math.max(0, rawLength - compactedLength),
+      applied: compactedLength !== rawLength,
+      strategies: compactedLength !== rawLength ? ['result_truncation'] : [],
+    },
+  };
+}
+
+function compactReadFileResult(result) {
+  const source = result && typeof result === 'object' ? result : {};
+  const compacted = compactTextPayload(source.content || '', {
+    maxChars: 2200,
+    maxLines: 40,
+  });
+  return {
+    result: {
+      ...source,
+      content: compacted.text,
+    },
+    metrics: compacted.metrics,
+  };
+}
+
+function compactPayloadForModel(toolName, result) {
+  switch (String(toolName || '').trim()) {
+    case 'http_request':
+      return compactHttpResult(result);
+    case 'browser_extract':
+    case 'session_search':
+      return compactExtractResult(result);
+    case 'web_search':
+      return compactSearchResult(result);
+    case 'read_file':
+      return compactReadFileResult(result);
+    default:
+      return {
+        result,
+        metrics: {
+          inputChars: 0,
+          outputChars: 0,
+          reducedChars: 0,
+          applied: false,
+          strategies: [],
+        },
+      };
+  }
+}
+
+module.exports = {
+  compactPayloadForModel,
+  compactTextPayload,
+  stripHtmlTags,
+};