Skip to content

Garry's Opinionated OpenClaw/Hermes Agent Brain

TypeScript

fix: pre-landing review fixes (deferred post-commit embedding resumes the import's engine scope; a closing engine's in-flight query embed stores nothing)

garrytanfe790c022b83
diff --git a/src/core/ai/query-embed-cache.ts b/src/core/ai/query-embed-cache.ts
index 96e77a7f28..fa760ff29d 100644
--- a/src/core/ai/query-embed-cache.ts
+++ b/src/core/ai/query-embed-cache.ts
@@ -44,9 +44,10 @@ export function storeQueryEmbedding(key: string, vector: Float32Array, startedAt
if (entries.size > MAX_ENTRIES) entries.delete(entries.keys().next().value!);
}
-/** Drop every entry an engine cached under `tag` (its unique cache tag, engine-gateway.ts) when it closes. */
+/** Drop every entry an engine cached under `tag` (its unique cache tag, engine-gateway.ts) when it closes; an embed still in flight then stores nothing. */
export function dropQueryEmbeddingsTagged(tag: string): void {
for (const key of entries.keys()) if (key.includes(tag)) entries.delete(key);
+ generation++;
}
/** @internal exported for tests: the cache keys, oldest first. */
diff --git a/src/core/import-file.ts b/src/core/import-file.ts
index 7d87ff815f..1e386f5dbb 100644
--- a/src/core/import-file.ts
+++ b/src/core/import-file.ts
@@ -70,7 +70,7 @@ import type { PageBodyPolicy } from './page-body/limits.ts';
import { parseFactsFence, renderFactsTable, restoreHiddenFactRows, factsGapWarning, replaceOrInsertFactsFence } from './facts-fence.ts';
import { assertOriginUnclaimed, isOriginClaimRefusal } from './persistence/origin-guard.ts';
import { fileBodyMatchesStored, readStoredBody } from './facts/file-body-guard.ts';
-import { needsEngineScope, withEngineScope } from './engine-scope.ts';
+import { currentEngineScope, needsEngineScope, runInEngineScope, withEngineScope } from './engine-scope.ts';
/**
* #2044 / #4548: row-level, visibility-aware fence merge for one page
@@ -917,9 +917,9 @@ export async function importFromContent(
}));
const searchable = await segmented?.afterCommit(engine);
-
if (postCommitEmbedding && !noEmbed && chunks.length > 0) {
- postCommitEmbedding(async () => {
+ const importScope = currentEngineScope();
+ postCommitEmbedding(() => runInEngineScope(importScope, async (): Promise<ImportEmbeddingResult> => {
try {
if (!persistedProjection) return { status: 'superseded' };
const signature = currentEmbeddingSignature();
@@ -929,7 +929,7 @@ export async function importFromContent(
} catch {
return { status: 'failed', error: 'Page content was saved, but embedding failed. Check the embedding provider and database on the brain host, then run gbrain embed --stale --source <source-id>.' };
}
- });
+ }));
}
return {
diff --git a/test/engine-cache-namespace.test.ts b/test/engine-cache-namespace.test.ts
index a9e1590b0f..651b190813 100644
--- a/test/engine-cache-namespace.test.ts
+++ b/test/engine-cache-namespace.test.ts
@@ -67,6 +67,24 @@ describe('settings.cache_namespace', () => {
expect(await askOnce(settingsFor(undefined, apiKey))).toBe(1);
}, 60_000);
+ test('a query embed still in flight when its engine closes leaves no entry behind for it', async () => {
+ let release!: () => void;
+ const gate = new Promise<void>(resolve => { release = resolve; });
+ __setEmbedTransportForTests((async ({ values }: any) => {
+ calls.push('in-flight');
+ await gate;
+ return { embeddings: values.map(() => Array.from({ length: EMBEDDING.dimensions }, (_, i) => (i % 7) + 1)), usage: { tokens: 1 } };
+ }) as any);
+ const engine = await openEngine(settingsFor(undefined, key()));
+ const pending = withEngineScope(engine, () => embedQuery('asked by brain-a just before it closed')).catch(() => null);
+ for (let i = 0; i < 200 && calls.length === 0; i++) await Bun.sleep(5);
+ expect(calls).toEqual(['in-flight']);
+ await engine.disconnect();
+ release();
+ await pending;
+ expect(__queryEmbedCacheKeysForTests().filter(k => k.includes('asked by brain-a just before it closed'))).toEqual([]);
+ }, 60_000);
+
test('the namespace is an opaque non-empty string, read back as given, and no tag carries the key', async () => {
for (const bad of ['', 42, { id: 'x' }, 'x'.repeat(257)]) {
const error = await openEngine({ ...settingsFor(undefined, key()), cache_namespace: bad as never }).then(e => e.disconnect().then(() => null), e => e);
diff --git a/test/engine-scope-entry-points.test.ts b/test/engine-scope-entry-points.test.ts
index f7c5ec4b3f..a4d3caa2d0 100644
--- a/test/engine-scope-entry-points.test.ts
+++ b/test/engine-scope-entry-points.test.ts
@@ -7,7 +7,7 @@
import { afterEach, describe, expect, test } from 'bun:test';
import { randomBytes, randomUUID } from 'node:crypto';
import { __setEmbedTransportForTests, configureGateway, embedQuery, resetGateway } from '../src/core/ai/gateway.ts';
-import { openEngine, type EngineSettings } from '../src/core/engine-open.ts';
+import { openEngine, withEngineScope, type EngineSettings } from '../src/core/engine-open.ts';
import { embeddedEngineInScope } from '../src/core/engine-scope.ts';
import { importFromContent } from '../src/core/import-file.ts';
import { hybridSearch, hybridSearchCached } from '../src/core/search/hybrid.ts';
@@ -58,6 +58,27 @@ describe('entry points a host calls without a scope', () => {
}
}, 120_000);
+ test('a deferred post-commit embedding from an import embeds with its engine\'s key, whatever scope drains it', async () => {
+ installEmbedStub();
+ const keyA = key('a');
+ const a = await openEngine(settingsFor(keyA));
+ const b = await openEngine(settingsFor(key('b')));
+ try {
+ await a.initSchema();
+ const deferred: Array<() => Promise<{ status: string }>> = [];
+ await importFromContent(a, 'notes/alpha-example', '# Alpha\n\nA note about acme-example for brain-a.', { onPostCommitEmbedding: complete => { deferred.push(complete); } });
+ await importFromContent(a, 'notes/beta-example', '# Beta\n\nAnother note about acme-example for brain-a.', { onPostCommitEmbedding: complete => { deferred.push(complete); } });
+ expect(deferred.length).toBe(2);
+ sent.length = 0;
+ expect((await deferred[0]()).status).toBe('embedded');
+ expect((await withEngineScope(b, () => deferred[1]())).status).toBe('embedded');
+ expect(sent.length).toBeGreaterThan(0);
+ expect(new Set(sent)).toEqual(new Set([`Bearer ${keyA}`]));
+ } finally {
+ await Promise.all([a.disconnect(), b.disconnect()]);
+ }
+ }, 120_000);
+
test('the minion worker runs each job in its engine\'s scope, whatever scope started it', async () => {
installEmbedStub();
const keyA = key('a');