neoagent 2.3.1-beta.86 → 2.3.1-beta.87

package/server/routes/memory.js

@@ -4,6 +4,11 @@ const rateLimit = require('express-rate-limit');
 const { requireAuth } = require('../middleware/auth');
 const { sanitizeError } = require('../utils/security');
 const { getAgentIdFromRequest, resolveAgentId } = require('../services/agents/manager');
+const {
+  buildLlmTransferPrompt,
+  parseLlmTransferText,
+  importanceForCategory,
+} = require('../services/memory/llm_transfer');
 
 router.use(requireAuth);
 
@@ -15,6 +20,16 @@ const apiKeyMutationLimiter = rateLimit({
   legacyHeaders: false,
 });
 
+const transferImportLimiter = rateLimit({
+  windowMs: 10 * 60 * 1000,
+  max: 20,
+  message: { error: 'Too many memory imports, try again later' },
+  standardHeaders: true,
+  legacyHeaders: false,
+});
+
+const MAX_TRANSFER_TEXT_BYTES = 60 * 1024;
+
 function normalizeMemoryIds(value) {
   return [...new Set(
     (Array.isArray(value) ? value : [])
@@ -262,6 +277,81 @@ router.get('/core', (req, res) => {
   res.json(coreMemory);
 });
 
+// ─────────────────────────────────────────────────────────────────────────────
+// LLM Transfer (prompt + import)
+// ─────────────────────────────────────────────────────────────────────────────
+
+router.get('/transfer-prompt', (req, res) => {
+  const prompt = buildLlmTransferPrompt({ agentLabel: 'NeoAgent' });
+  res.json({ prompt });
+});
+
+router.post('/transfer-import', transferImportLimiter, async (req, res) => {
+  const mm = req.app.locals.memoryManager;
+  const userId = req.session.userId;
+  const agentId = resolveAgentId(userId, getAgentIdFromRequest(req));
+  const text = String(req.body?.text || '').trim();
+  if (!text) {
+    return res.status(400).json({ error: 'text is required' });
+  }
+  if (Buffer.byteLength(text, 'utf8') > MAX_TRANSFER_TEXT_BYTES) {
+    return res.status(413).json({ error: 'text exceeds 60KB limit' });
+  }
+
+  const applyBehaviorNotes = req.body?.applyBehaviorNotes !== false;
+  const applyCoreMemory = req.body?.applyCoreMemory !== false;
+
+  try {
+    const parsed = parseLlmTransferText(text);
+    let importedCount = 0;
+    let skippedCount = 0;
+
+    for (const memory of parsed.memories) {
+      const content = String(memory.content || '').trim();
+      if (!content) {
+        skippedCount += 1;
+        continue;
+      }
+      await mm.saveMemory(userId, content, memory.category, importanceForCategory(memory.category), {
+        agentId,
+        sourceRef: {
+          sourceType: 'llm_import',
+          sourceLabel: 'LLM memory transfer',
+        },
+        metadata: {
+          importedFrom: 'llm_transfer',
+        },
+      });
+      importedCount += 1;
+    }
+
+    let coreUpdatedCount = 0;
+    if (applyCoreMemory && parsed.coreEntries) {
+      for (const [key, value] of Object.entries(parsed.coreEntries)) {
+        if (!key || key === 'active_context') continue;
+        mm.updateCore(userId, key, value, { agentId });
+        coreUpdatedCount += 1;
+      }
+    }
+
+    let behaviorNotesUpdated = false;
+    if (applyBehaviorNotes && parsed.behaviorNotes) {
+      mm.setAssistantBehaviorNotes(userId, parsed.behaviorNotes, { agentId });
+      behaviorNotesUpdated = true;
+    }
+
+    res.json({
+      importedCount,
+      skippedCount,
+      coreUpdatedCount,
+      behaviorNotesUpdated,
+      warnings: parsed.warnings || [],
+    });
+  } catch (err) {
+    res.status(500).json({ error: sanitizeError(err) });
+  }
+});
+
 router.put('/core/:key', (req, res) => {
   const mm = req.app.locals.memoryManager;
   const userId = req.session.userId;

package/server/routes/social_video.js

@@ -0,0 +1,62 @@
+const express = require('express');
+const { requireAuth } = require('../middleware/auth');
+const { sanitizeError } = require('../utils/security');
+
+const router = express.Router();
+
+router.use(requireAuth);
+
+router.get('/health', async (req, res) => {
+  try {
+    const service = req.app?.locals?.socialVideoService;
+    if (!service || typeof service.getHealthStatus !== 'function') {
+      return res.status(503).json({
+        ready: false,
+        error: 'Social video service is unavailable.',
+      });
+    }
+    const health = await service.getHealthStatus({
+      forceRefresh: req.query?.refresh === '1' || req.query?.refresh === 'true',
+    });
+    return res.json(health);
+  } catch (error) {
+    return res.status(500).json({ error: sanitizeError(error) });
+  }
+});
+
+router.post('/extract', async (req, res) => {
+  try {
+    const service = req.app?.locals?.socialVideoService;
+    if (!service || typeof service.extractFromUrl !== 'function') {
+      return res.status(503).json({ error: 'Social video service is unavailable.' });
+    }
+    if (!req.session || !req.session.userId) {
+      return res.status(401).json({ error: 'Authentication required.' });
+    }
+
+    const sourceUrl = String(req.body?.url || '').trim();
+    if (!sourceUrl) {
+      return res.status(400).json({ error: 'url is required.' });
+    }
+
+    const result = await service.extractFromUrl(req.session.userId, sourceUrl, {
+      includeFrame: req.body?.include_frame !== false,
+      forceStt: req.body?.force_stt === true,
+    });
+
+    if (result?.setup?.ready === false) {
+      return res.status(503).json(result);
+    }
+
+    if (Array.isArray(result.errors) && result.errors.length > 0) {
+      const failed = !result.title && !result.description && !result.transcript && !result.frameImage;
+      return res.status(failed ? 422 : 200).json(result);
+    }
+
+    return res.json(result);
+  } catch (error) {
+    return res.status(500).json({ error: sanitizeError(error) });
+  }
+});
+
+module.exports = router;

package/server/services/ai/systemPrompt.js

@@ -94,6 +94,7 @@ Separate facts from inferences. If you are inferring from logs, code, or partial
 When evidence conflicts, state the conflict instead of smoothing it over.
 Source priority for factual work is: direct tool output and first-party integrations in this run, then authoritative primary sources, then other web sources, then model memory. Search-result snippets, link previews, and remembered facts are leads, not evidence.
 If the user provides a URL, open or fetch that URL before describing its contents unless the user only wants formatting help with the URL itself.
+If the user sends only a video link with no extra instruction, default to researching and fact-checking the video's key claims and context.
 
 DON'T REPEAT YOURSELF
 State a limitation or error once. If the user pushes back, try a different approach before restating the same failure. Repeating the same dead-end across five messages is useless.

package/server/services/ai/toolResult.js

@@ -112,6 +112,26 @@ function compactToolResult(toolName, toolArgs = {}, toolResult, options = {}) {
       });
       break;
 
+    case 'social_video_extract':
+      envelope = trimObject({
+        tool: toolName,
+        platform: toolResult?.platform,
+        sourceUrl: toolResult?.sourceUrl,
+        resolvedUrl: toolResult?.resolvedUrl,
+        title: clampText(toolResult?.title || '', Math.floor(softLimit * 0.25)),
+        description: clampText(toolResult?.description || '', Math.floor(softLimit * 0.25)),
+        transcriptSource: toolResult?.transcriptSource,
+        transcriptPreview: lineExcerpt(toolResult?.transcript || '', 6, Math.floor(softLimit * 0.35)),
+        frameImage: trimObject({
+          url: toolResult?.frameImage?.url,
+          source: toolResult?.frameImage?.source,
+        }),
+        setupReady: toolResult?.setup?.ready,
+        warningCount: Array.isArray(toolResult?.warnings) ? toolResult.warnings.length : 0,
+        errorCount: Array.isArray(toolResult?.errors) ? toolResult.errors.length : 0,
+      });
+      break;
+
     case 'android_dump_ui':
     case 'android_observe':
       envelope = trimObject({

package/server/services/ai/tools.js

@@ -1267,6 +1267,19 @@ function getAvailableTools(app, options = {}) {
                 },
                 required: ['query']
             }
+        },
+        {
+            name: 'social_video_extract',
+            description: 'Extract title, description, transcript, and one representative frame image from a public social video URL (YouTube, TikTok, Instagram, or X) without social API keys.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: 'Public social video URL.' },
+                    include_frame: { type: 'boolean', description: 'Whether to return one representative frame image artifact (default true).' },
+                    force_stt: { type: 'boolean', description: 'Force speech-to-text fallback even if captions are present.' }
+                },
+                required: ['url']
+            }
         }
     ];
 
@@ -1392,6 +1405,7 @@ async function executeTool(toolName, args, context, engine) {
     const sk = () => app?.locals?.skillRunner || engine.skillRunner;
     const taskRuntime = () => app?.locals?.taskRuntime || engine.taskRuntime;
     const rec = () => app?.locals?.recordingManager || null;
+    const socialVideo = () => app?.locals?.socialVideoService || null;
     const widgets = () => app?.locals?.widgetService || null;
     const artifactStore = app?.locals?.artifactStore || null;
 
@@ -1950,6 +1964,21 @@ async function executeTool(toolName, args, context, engine) {
             };
         }
 
+        case 'social_video_extract': {
+            const service = socialVideo();
+            if (!service || typeof service.extractFromUrl !== 'function') {
+                return { error: 'Social video extraction service is unavailable.' };
+            }
+            const sourceUrl = String(args.url || '').trim();
+            if (!sourceUrl) {
+                return { error: 'url is required' };
+            }
+            return await service.extractFromUrl(userId, sourceUrl, {
+                includeFrame: args.include_frame !== false,
+                forceStt: args.force_stt === true,
+            });
+        }
+
         case 'memory_write': {
             const { MemoryManager } = require('../memory/manager');
             const mm = new MemoryManager();

package/server/services/manager.js

@@ -13,6 +13,7 @@ const { WidgetService } = require('./widgets/service');
 const { setupWebSocket } = require('./websocket');
 const { registerMessagingAutomation } = require('./messaging/automation');
 const { RecordingManager } = require('./recordings/manager');
+const { SocialVideoService } = require('./social_video');
 const { VoiceRuntimeManager } = require('./voice/runtimeManager');
 const { AuthProviderManager } = require('./account/auth_provider_manager');
 const { IntegrationManager } = require('./integrations/manager');
@@ -318,6 +319,19 @@ function createRecordingManager(app, io) {
   return recordingManager;
 }
 
+function createSocialVideoService(app) {
+  const socialVideoService = registerLocal(
+    app,
+    'socialVideoService',
+    new SocialVideoService({
+      artifactStore: app.locals.artifactStore,
+      runtimeManager: app.locals.runtimeManager,
+    }),
+  );
+  logServiceReady('Social video service ready');
+  return socialVideoService;
+}
+
 function createWidgetService(app) {
   const widgetService = registerLocal(
     app,
@@ -460,6 +474,7 @@ async function startServices(app, io) {
 
     const messagingManager = createMessagingManager(app, io, agentEngine);
     const recordingManager = createRecordingManager(app, io);
+    createSocialVideoService(app);
     createWidgetService(app);
     createWearableService(app);
     createScreenRecorder(app);

package/server/services/memory/llm_transfer.js

@@ -0,0 +1,217 @@
+const HEADING_ALIASES = {
+  profile: 'identity',
+  identity: 'identity',
+  preferences: 'preferences',
+  preference: 'preferences',
+  projects: 'projects',
+  project: 'projects',
+  contacts: 'contacts',
+  contact: 'contacts',
+  events: 'events',
+  event: 'events',
+  tasks: 'tasks',
+  task: 'tasks',
+  'assistant self': 'assistant_self',
+  self: 'assistant_self',
+  'behavior notes': '__behavior_notes',
+  'assistant behavior notes': '__behavior_notes',
+  'core memory': '__core',
+  'core memories': '__core',
+  'other memories': 'episodic',
+  other: 'episodic',
+  misc: 'episodic',
+  miscellaneous: 'episodic',
+};
+
+const SECTION_PRIORITY = {
+  identity: 8,
+  preferences: 7,
+  projects: 6,
+  contacts: 6,
+  events: 6,
+  tasks: 6,
+  assistant_self: 7,
+  episodic: 5,
+};
+
+const MAX_MEMORY_LENGTH = 1200;
+const MAX_MEMORIES = 200;
+
+function normalizeHeadingLabel(input) {
+  return String(input || '')
+    .trim()
+    .replace(/^#+\s*/, '')
+    .replace(/[:]+$/g, '')
+    .replace(/\s+/g, ' ')
+    .toLowerCase();
+}
+
+function detectHeading(line) {
+  const trimmed = String(line || '').trim();
+  if (!trimmed) return null;
+  const normalized = normalizeHeadingLabel(trimmed);
+  if (HEADING_ALIASES[normalized]) return normalized;
+  return null;
+}
+
+function splitSections(text) {
+  const lines = String(text || '').split(/\r?\n/);
+  const sections = [];
+  let current = { heading: 'other', lines: [] };
+
+  for (const line of lines) {
+    const heading = detectHeading(line);
+    if (heading) {
+      if (current.lines.length || current.heading) {
+        sections.push(current);
+      }
+      current = { heading, lines: [] };
+      continue;
+    }
+    current.lines.push(line);
+  }
+
+  if (current.lines.length || current.heading) {
+    sections.push(current);
+  }
+
+  return sections;
+}
+
+function collectBulletItems(lines) {
+  const items = [];
+  for (const line of lines) {
+    const match = String(line || '').match(/^\s*(?:[-*]|\u2022|\d+\.)\s+(.*)$/);
+    if (match && match[1]) {
+      const value = match[1].trim();
+      if (value) items.push(value);
+    }
+  }
+  return items;
+}
+
+function collapseParagraph(lines) {
+  const parts = lines
+    .map((line) => String(line || '').trim())
+    .filter((line) => line.length > 0);
+  if (!parts.length) return '';
+  return parts.join(' ');
+}
+
+function normalizeMemoryContent(text) {
+  const cleaned = String(text || '').trim();
+  if (!cleaned) return '';
+  if (cleaned.length <= MAX_MEMORY_LENGTH) return cleaned;
+  return cleaned.slice(0, MAX_MEMORY_LENGTH).trim();
+}
+
+function buildLlmTransferPrompt({ agentLabel = 'NeoAgent' } = {}) {
+  return [
+    'You are preparing a memory export for ' + agentLabel + '.',
+    'Return a concise, structured, natural language summary of everything you remember about the user.',
+    '',
+    'Rules:',
+    '- Use only plain text. No JSON or code blocks.',
+    '- Use short bullet points where possible.',
+    '- Omit secrets, passwords, API keys, or anything sensitive.',
+    '- If a section has no data, omit the section.',
+    '',
+    'Use these sections and formatting:',
+    '# Profile',
+    '- Key identity facts about the user.',
+    '# Preferences',
+    '- Stable preferences, likes, dislikes, habits.',
+    '# Projects',
+    '- Ongoing projects, goals, responsibilities.',
+    '# Contacts',
+    '- Important people or organizations and the relationship.',
+    '# Events',
+    '- Important dates or recurring events.',
+    '# Tasks',
+    '- Open tasks or commitments the user expects to remember.',
+    '# Behavior Notes',
+    'Short guidance for how the assistant should behave.',
+    '# Core Memory',
+    'key: value entries for critical facts that should always be pinned.',
+    '# Other Memories',
+    '- Anything else that does not fit above.',
+  ].join('\n');
+}
+
+function parseLlmTransferText(text) {
+  const sections = splitSections(text);
+  const memories = [];
+  const coreEntries = {};
+  let behaviorNotes = '';
+  const warnings = [];
+
+  for (const section of sections) {
+    const heading = normalizeHeadingLabel(section.heading || 'other');
+    const alias = HEADING_ALIASES[heading] || 'episodic';
+    const lines = section.lines || [];
+
+    if (alias === '__behavior_notes') {
+      const notes = collapseParagraph(lines);
+      if (notes) behaviorNotes = notes;
+      continue;
+    }
+
+    if (alias === '__core') {
+      for (const rawLine of lines) {
+        const line = String(rawLine || '').trim();
+        if (!line) continue;
+        const cleanedLine = line.replace(/^[-*]\s*/, '');
+        const colonIndex = cleanedLine.indexOf(':');
+        if (colonIndex <= 0) continue;
+        const key = cleanedLine.slice(0, colonIndex).trim();
+        const value = cleanedLine.slice(colonIndex + 1).trim();
+        if (!key || !value) continue;
+        if (key === 'active_context') continue;
+        coreEntries[key] = value;
+      }
+      continue;
+    }
+
+    const bulletItems = collectBulletItems(lines);
+    if (bulletItems.length) {
+      for (const item of bulletItems) {
+        const content = normalizeMemoryContent(item);
+        if (!content) continue;
+        memories.push({
+          category: alias,
+          content,
+        });
+      }
+      continue;
+    }
+
+    const paragraph = normalizeMemoryContent(collapseParagraph(lines));
+    if (paragraph) {
+      memories.push({
+        category: alias,
+        content: paragraph,
+      });
+    }
+  }
+
+  if (memories.length > MAX_MEMORIES) {
+    warnings.push('Import exceeded ' + MAX_MEMORIES + ' items; extra entries were skipped.');
+  }
+
+  return {
+    memories: memories.slice(0, MAX_MEMORIES),
+    coreEntries,
+    behaviorNotes,
+    warnings,
+  };
+}
+
+function importanceForCategory(category) {
+  return SECTION_PRIORITY[category] || 5;
+}
+
+module.exports = {
+  buildLlmTransferPrompt,
+  parseLlmTransferText,
+  importanceForCategory,
+};

package/server/services/social_video/adapters/base.js

@@ -0,0 +1,26 @@
+'use strict';
+
+class SocialVideoAdapter {
+  constructor(options = {}) {
+    this.platform = String(options.platform || 'unknown');
+    this.hosts = Array.isArray(options.hosts)
+      ? options.hosts.map((host) => String(host || '').toLowerCase()).filter(Boolean)
+      : [];
+    this.captionLanguages = Array.isArray(options.captionLanguages)
+      ? options.captionLanguages.map((value) => String(value || '').toLowerCase()).filter(Boolean)
+      : ['en', 'en-us'];
+  }
+
+  supportsHost(hostname) {
+    const host = String(hostname || '').toLowerCase();
+    return this.hosts.some((candidate) => host === candidate || host.endsWith(`.${candidate}`));
+  }
+
+  getCaptionLanguagePreferences() {
+    return [...this.captionLanguages];
+  }
+}
+
+module.exports = {
+  SocialVideoAdapter,
+};

package/server/services/social_video/adapters/index.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const { YouTubeAdapter } = require('./youtube');
+const { TikTokAdapter } = require('./tiktok');
+const { InstagramAdapter } = require('./instagram');
+const { XAdapter } = require('./x');
+
+const ADAPTERS = [
+  new YouTubeAdapter(),
+  new TikTokAdapter(),
+  new InstagramAdapter(),
+  new XAdapter(),
+];
+
+function getAdapterForPlatform(platform) {
+  const normalized = String(platform || '').trim().toLowerCase();
+  return ADAPTERS.find((adapter) => adapter.platform === normalized) || null;
+}
+
+function getSupportedAdapters() {
+  return [...ADAPTERS];
+}
+
+module.exports = {
+  getAdapterForPlatform,
+  getSupportedAdapters,
+};

package/server/services/social_video/adapters/instagram.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const { SocialVideoAdapter } = require('./base');
+
+class InstagramAdapter extends SocialVideoAdapter {
+  constructor() {
+    super({
+      platform: 'instagram',
+      hosts: ['instagram.com', 'www.instagram.com', 'm.instagram.com', 'instagr.am'],
+      captionLanguages: ['en', 'en-us'],
+    });
+  }
+}
+
+module.exports = {
+  InstagramAdapter,
+};

package/server/services/social_video/adapters/tiktok.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const { SocialVideoAdapter } = require('./base');
+
+class TikTokAdapter extends SocialVideoAdapter {
+  constructor() {
+    super({
+      platform: 'tiktok',
+      hosts: ['tiktok.com', 'www.tiktok.com', 'm.tiktok.com', 'vm.tiktok.com', 'vt.tiktok.com'],
+      captionLanguages: ['en', 'en-us'],
+    });
+  }
+}
+
+module.exports = {
+  TikTokAdapter,
+};

package/server/services/social_video/adapters/x.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const { SocialVideoAdapter } = require('./base');
+
+class XAdapter extends SocialVideoAdapter {
+  constructor() {
+    super({
+      platform: 'x',
+      hosts: ['x.com', 'twitter.com'],
+      captionLanguages: ['en', 'en-us'],
+    });
+  }
+}
+
+module.exports = {
+  XAdapter,
+};

package/server/services/social_video/adapters/youtube.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const { SocialVideoAdapter } = require('./base');
+
+class YouTubeAdapter extends SocialVideoAdapter {
+  constructor() {
+    super({
+      platform: 'youtube',
+      hosts: ['youtube.com', 'www.youtube.com', 'youtu.be'],
+      captionLanguages: ['en', 'en-us', 'en-gb'],
+    });
+  }
+}
+
+module.exports = {
+  YouTubeAdapter,
+};