Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

fix: summarize memory embeddings without host tools (#11038)

Adam Eivy7ed2d6ffa718
diff --git a/server/routes/memory.embeddingAuthority.test.js b/server/routes/memory.embeddingAuthority.test.js
new file mode 100644
index 0000000000..ad182b959c
--- /dev/null
+++ b/server/routes/memory.embeddingAuthority.test.js
@@ -0,0 +1,140 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { EventEmitter } from 'node:events';
+import express from 'express';
+import { request } from '../lib/testHelper.js';
+import { errorMiddleware } from '../lib/errorHandler.js';
+
+// Exercise the real gates, memory route, embedding budget and summarizer. All
+// persisted state, provider execution and embedding HTTP are synthetic sinks.
+vi.mock('../services/auth.js', () => ({
+ isAuthEnabled: vi.fn().mockResolvedValue(false),
+ verifyPassword: vi.fn(),
+ verifyRequestSession: vi.fn(),
+}));
+vi.mock('../services/settings.js', () => ({
+ getSettings: vi.fn().mockResolvedValue({}),
+ settingsEvents: new EventEmitter(),
+}));
+vi.mock('../services/voice/config.js', () => ({ getVoiceConfig: vi.fn() }));
+vi.mock('../services/instanceIdentity.js', () => ({ loadData: vi.fn() }));
+vi.mock('../lib/securityAuditLog.js', () => ({ logSecurityEvent: vi.fn() }));
+vi.mock('../services/memoryBackend.js', () => ({ createMemory: vi.fn(), ensureBackend: vi.fn() }));
+vi.mock('../services/memorySync.js', () => ({}));
+vi.mock('../services/memoryRunUsage.js', () => ({ findRecentRunsUsingMemory: vi.fn() }));
+vi.mock('../lib/db.js', () => ({ checkHealth: vi.fn() }));
+vi.mock('../services/cosState.js', () => ({ getConfig: vi.fn() }));
+vi.mock('../services/providers.js', () => ({ getProviderById: vi.fn() }));
+vi.mock('../services/brainStorage.js', () => ({ loadMeta: vi.fn() }));
+vi.mock('../services/chatgptImport.js', () => ({ readArchivedConversation: vi.fn() }));
+vi.mock('../services/promptRunner.js', () => ({ runPromptThroughProvider: vi.fn() }));
+
+import memoryRoutes from './memory.js';
+import { authGate, hostControlRouteGate, hostControlBodyGate } from '../services/authGate.js';
+import { isAuthEnabled } from '../services/auth.js';
+import { createMemory } from '../services/memoryBackend.js';
+import { reinitialize } from '../services/memoryEmbeddings.js';
+import { getConfig } from '../services/cosState.js';
+import { getProviderById } from '../services/providers.js';
+import { loadMeta } from '../services/brainStorage.js';
+import { runPromptThroughProvider } from '../services/promptRunner.js';
+
+const embeddingProvider = { id: 'embed', type: 'api', endpoint: 'https://embedding.example.com/v1' };
+const summaryProvider = { id: 'summary', type: 'cli', command: 'claude', defaultModel: 'example-model' };
+const vector = [0.1, 0.2, 0.3];
+const budget = Math.floor(2048 * 0.85 * 3);
+const longContent = 'Reference text. '.repeat(420);
+let app;
+let inputs;
+
+beforeEach(() => {
+ vi.resetAllMocks();
+ isAuthEnabled.mockResolvedValue(false);
+ reinitialize();
+ inputs = [];
+ getConfig.mockResolvedValue({ embeddingProviderId: 'embed', embeddingModel: 'example-embed' });
+ loadMeta.mockResolvedValue({ defaultProvider: 'summary' });
+ getProviderById.mockImplementation(async (id) => id === 'embed' ? embeddingProvider : summaryProvider);
+ runPromptThroughProvider.mockResolvedValue({ text: 'A factual summary.' });
+ createMemory.mockImplementation(async (data, embedding) => ({ id: 'example-memory', ...data, embedding }));
+
+ const realFetch = globalThis.fetch;
+ vi.spyOn(globalThis, 'fetch').mockImplementation(async (url, options) => {
+ if (String(url).startsWith('http://127.0.0.1:')) return realFetch(url, options);
+ if (String(url) === 'https://embedding.example.com/api/v0/models') {
+ return new Response('', { status: 404 });
+ }
+ if (String(url) === 'https://embedding.example.com/v1/embeddings') {
+ inputs.push(JSON.parse(options.body).input);
+ return new Response(JSON.stringify({ data: [{ embedding: vector }] }));
+ }
+ throw new Error('Unexpected network request in memory authority test');
+ });
+ app = express();
+ app.use((req, res, next) => {
+ Object.defineProperty(req.socket, 'remoteAddress', { value: '192.0.2.10', configurable: true });
+ next();
+ });
+ app.use(authGate);
+ app.use(hostControlRouteGate);
+ app.use(express.json());
+ app.use(hostControlBodyGate);
+ app.use('/api/memory', memoryRoutes);
+ app.use(errorMiddleware);
+});
+
+afterEach(() => vi.restoreAllMocks());
+
+describe('memory creation embedding authority (#11038)', () => {
+ // Uniquely catches accepted data-only remote writes acquiring host tools in
+ // the automatic over-budget summarizer, before the memory is persisted.
+ it('summarizes an over-budget remote memory with tools and fallback disabled', async () => {
+ const response = await request(app).post('/api/memory').send({ type: 'fact', content: longContent });
+
+ expect(response.status).toBe(201);
+ expect(response.body.content).toBe(longContent);
+ expect(response.body.embedding).toEqual(vector);
+ expect(runPromptThroughProvider).toHaveBeenCalledExactlyOnceWith(expect.objectContaining({
+ provider: summaryProvider,
+ prompt: expect.stringContaining(longContent),
+ toolFree: true,
+ allowFallback: false,
+ }));
+ expect(inputs).toEqual(['Type: fact\nCategory: other\nA factual summary.']);
+ });
+
+ it.each([
+ { id: 'summary', type: 'tui', command: 'claude' },
+ { id: 'summary', type: 'cli', command: 'codex' },
+ ])('truncates safely when the configured summarizer cannot disable tools ($type)', async (provider) => {
+ getProviderById.mockImplementation(async (id) => id === 'embed' ? embeddingProvider : provider);
+
+ const response = await request(app).post('/api/memory').send({ type: 'fact', content: longContent });
+
+ expect(response.status).toBe(201);
+ expect(response.body.content).toBe(longContent);
+ expect(response.body.embedding).toEqual(vector);
+ expect(runPromptThroughProvider).not.toHaveBeenCalled();
+ expect(inputs).toEqual([`Type: fact\nCategory: other\n${longContent}`.slice(0, budget)]);
+ });
+
+ it('preserves the write and bounded embedding when tool-free inference is unavailable', async () => {
+ runPromptThroughProvider.mockRejectedValue(new Error('Synthetic provider unavailable'));
+
+ const response = await request(app).post('/api/memory').send({ type: 'fact', content: longContent });
+
+ expect(response.status).toBe(201);
+ expect(response.body.content).toBe(longContent);
+ expect(response.body.embedding).toEqual(vector);
+ expect(runPromptThroughProvider).toHaveBeenCalledTimes(1);
+ expect(inputs).toEqual([`Type: fact\nCategory: other\n${longContent}`.slice(0, budget)]);
+ });
+
+ it('embeds an in-budget remote memory directly without provider inference', async () => {
+ const response = await request(app).post('/api/memory').send({ type: 'fact', content: 'A short fact.' });
+
+ expect(response.status).toBe(201);
+ expect(response.body.embedding).toEqual(vector);
+ expect(runPromptThroughProvider).not.toHaveBeenCalled();
+ expect(inputs).toEqual(['Type: fact\nCategory: other\nA short fact.']);
+ });
+});
diff --git a/server/services/memorySummarizer.js b/server/services/memorySummarizer.js
index 33e9c574cd..4858ead456 100644
--- a/server/services/memorySummarizer.js
+++ b/server/services/memorySummarizer.js
@@ -21,6 +21,7 @@ import { getProviderById } from './providers.js';
import { loadMeta } from './brainStorage.js';
import { readArchivedConversation } from './chatgptImport.js';
import { runPromptThroughProvider } from './promptRunner.js';
+import { isToolFreeOneShotProvider } from '../lib/providerVendors.js';
// Preferred summarizer model when the Brain default doesn't resolve. gpt-oss:20b
// is the typical Brain default and has ample context for a full transcript.
@@ -85,7 +86,7 @@ async function resolveSourceText(memory, fallbackText) {
*/
export async function summarizeForEmbedding(memory, fallbackText) {
const summarizer = await resolveSummarizer();
- if (!summarizer) return null;
+ if (!summarizer || !isToolFreeOneShotProvider(summarizer.provider)) return null;
const sourceText = await resolveSourceText(memory, fallbackText);
if (!sourceText?.trim()) return null;
@@ -96,6 +97,12 @@ export async function summarizeForEmbedding(memory, fallbackText) {
provider: summarizer.provider,
model: summarizer.model,
prompt,
+ // Memory text is reference data, never authority to use host tools. The
+ // runner's toolFree flag only constrains supported CLI one-shots; pin the
+ // admitted provider so proactive/runtime fallback cannot switch to a TUI
+ // or a CLI without tool-disable support. Failure falls back to truncation.
+ toolFree: true,
+ allowFallback: false,
source: 'memory-embedding-summary'
}).catch((err) => {
console.warn(`⚠️ Embedding summarization failed (${summarizer.model}): ${err.message}`);
diff --git a/server/services/memorySummarizer.test.js b/server/services/memorySummarizer.test.js
index 55b76bfbeb..b50dd91d19 100644
--- a/server/services/memorySummarizer.test.js
+++ b/server/services/memorySummarizer.test.js
@@ -37,6 +37,10 @@ describe('memorySummarizer — summarizeForEmbedding', () => {
expect(prompt).not.toContain('the short truncated preview');
// Uses the Brain default model.
expect(runPromptThroughProvider.mock.calls[0][0].model).toBe('gpt-oss:20b');
+ expect(runPromptThroughProvider).toHaveBeenCalledWith(expect.objectContaining({
+ toolFree: true,
+ allowFallback: false,
+ }));
expect(out).toBe('a dense summary'); // trimmed
});