Skip to content

Commit c90b678

Browse files
t3dotggclaude
andauthored
fix(server): Find frees searched thread text after one idle minute (#34132)
Co-authored-by: Claude Fable 5.2 <[email protected]>
1 parent 92f1b8e commit c90b678

2 files changed

Lines changed: 66 additions & 22 deletions

File tree

‎apps/server/src/orchestration-v2/ThreadFind.test.ts‎

Lines changed: 39 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
11
import { assert, it, describe } from "@effect/vitest";
2+
import { searchableMessageSegments } from "@t3tools/shared/threadFindText";
23
import {
34
EventId,
45
MessageId,
@@ -19,6 +20,8 @@ import * as Effect from "effect/Effect";
1920
import * as Layer from "effect/Layer";
2021
import * as SqlClient from "effect/sql/SqlClient";
2122
import * as Stream from "effect/Stream";
23+
import * as TestClock from "effect/testing/TestClock";
24+
import { vi } from "vite-plus/test";
2225

2326
import * as SqlitePersistence from "../persistence/Sqlite.ts";
2427
import * as ProjectionStore from "./ProjectionStore.ts";
@@ -31,6 +34,8 @@ import {
3134
} from "./threadHistoryPaging.ts";
3235
import { projectTurnItemForWire } from "./WireProjection.ts";
3336

37+
vi.mock("@t3tools/shared/threadFindText", { spy: true });
38+
3439
const layerTest = Layer.mergeAll(EventStore.layer, ProjectionStore.layer, ProjectStore.layer).pipe(
3540
Layer.provideMerge(SqlitePersistence.layerMemory),
3641
);
@@ -460,6 +465,40 @@ describe("V2 thread find", () => {
460465
}).pipe(Effect.provide(layerTest)),
461466
);
462467

468+
it.effect("keeps its caches while Find is in use and drops them after one idle minute", () =>
469+
Effect.gen(function* () {
470+
const projection = yield* setup;
471+
yield* putItems([item("one", 1, "idle needle one"), item("two", 2, "idle needle two")]);
472+
const parses = () =>
473+
vi
474+
.mocked(searchableMessageSegments)
475+
.mock.calls.filter(([message]) => message.text.startsWith("idle needle")).length;
476+
const search = (query: string) => projection.searchThread({ threadId, query });
477+
// One idle minute passes inside this search. The later counts fail if it let the caches go.
478+
yield* projection.searchThreadStream({ threadId, query: "needle" }).pipe(
479+
Stream.tap((frame) =>
480+
frame.complete === false ? TestClock.adjust("1 minute") : Effect.void,
481+
),
482+
Stream.runDrain,
483+
);
484+
assert.equal(parses(), 2);
485+
yield* TestClock.adjust("40 seconds");
486+
yield* search("idle");
487+
yield* TestClock.adjust("40 seconds");
488+
// A repeated query is answered from the completed scan and still counts as use.
489+
const repeated = yield* projection
490+
.searchThreadStream({ threadId, query: "needle" })
491+
.pipe(Stream.runCollect);
492+
assert.equal(repeated.length, 1);
493+
yield* TestClock.adjust("40 seconds");
494+
yield* search("one");
495+
assert.equal(parses(), 2);
496+
yield* TestClock.adjust("1 minute");
497+
yield* search("needle");
498+
assert.equal(parses(), 4);
499+
}).pipe(Effect.provide(layerTest)),
500+
);
501+
463502
it.effect("invalidates cached counts when streamed text changes or a run rolls back", () =>
464503
Effect.gen(function* () {
465504
const projection = yield* setup;

‎apps/server/src/orchestration-v2/ThreadFind.ts‎

Lines changed: 27 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,7 @@ import { countThreadSearchOccurrences } from "@t3tools/shared/threadSearch";
1212
import * as Cache from "effect/Cache";
1313
import * as Data from "effect/Data";
1414
import * as Effect from "effect/Effect";
15+
import * as RcRef from "effect/RcRef";
1516
import * as Schema from "effect/Schema";
1617
import * as Stream from "effect/Stream";
1718
import * as NodeSqliteClient from "@t3tools/shared/nodeSqliteClient";
@@ -38,6 +39,14 @@ interface FindDocument extends FindRow {
3839
readonly runId: OrchestrationV2TurnItem["runId"];
3940
readonly count: number;
4041
}
42+
type CompletedScans = Map<
43+
string,
44+
{
45+
sequence: number;
46+
documents: readonly FindDocument[];
47+
sourceThreadIds: readonly ThreadId[];
48+
}
49+
>;
4150
class TextKey extends Data.Class<{
4251
text: string;
4352
role: "user" | "assistant" | "plan";
@@ -232,26 +241,21 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
232241
});
233242
});
234243
});
235-
// Scans visit every message; a cache smaller than the thread churns without hits.
236-
const textCache = yield* Cache.make({
237-
capacity: 8192,
238-
timeToLive: "1 minute",
239-
lookup: (key: TextKey) => Effect.sync(() => parseText(key)),
240-
});
241-
// Bounded separately because each entry can hold a large body; typing reuses the parse.
242-
const largeTextCache = yield* Cache.make({
243-
capacity: 32,
244-
timeToLive: "1 minute",
245-
lookup: (key: TextKey) => Effect.sync(() => parseText(key)),
244+
const makeTextCache = (capacity: number) =>
245+
Cache.make({ capacity, lookup: (key: TextKey) => Effect.sync(() => parseText(key)) });
246+
// Text keys are message content, so entries never go stale. Cache TTL only expires on access
247+
// and would keep the last searched threads forever. Each search borrows this for its whole
248+
// stream, and all of it is dropped once Find is idle.
249+
const findCaches = yield* RcRef.make({
250+
acquire: Effect.all({
251+
// Scans visit every message; a cache smaller than the thread churns without hits.
252+
text: makeTextCache(8192),
253+
// Bounded separately because each entry can hold a large body; typing reuses the parse.
254+
largeText: makeTextCache(32),
255+
scans: Effect.sync((): CompletedScans => new Map()),
256+
}),
257+
idleTimeToLive: "1 minute",
246258
});
247-
const scans = new Map<
248-
string,
249-
{
250-
sequence: number;
251-
documents: readonly FindDocument[];
252-
sourceThreadIds: readonly ThreadId[];
253-
}
254-
>();
255259
const readRevision = Effect.fn("ThreadFind.readRevision")(function* (
256260
threadIds: readonly ThreadId[],
257261
) {
@@ -275,7 +279,7 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
275279
return revision[0]?.sequence ?? 0;
276280
});
277281
const snapshot = Effect.fn("ThreadFind.snapshot")(
278-
function* (input: OrchestrationV2SearchThreadInput) {
282+
function* (input: OrchestrationV2SearchThreadInput, scans: CompletedScans) {
279283
const { threadId } = input;
280284
const active = yield* sql<{ cwd: string | null }>`
281285
SELECT COALESCE(json_extract(t.payload_json, '$.worktreePath'), p.workspace_root) AS cwd
@@ -326,8 +330,9 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
326330
const searchThreadStream = (input: OrchestrationV2SearchThreadInput) =>
327331
Stream.unwrap(
328332
Effect.gen(function* () {
333+
const { scans, ...textCache } = yield* RcRef.get(findCaches);
329334
// Release SQLite before decoding and parsing. Both frames describe one snapshot.
330-
const data = yield* snapshot(input);
335+
const data = yield* snapshot(input, scans);
331336
if (data.result) return Stream.succeed(data.result);
332337
const { payloads, cwd, sequence, cacheKey, sourceThreadIds } = data;
333338
const decode = (row: FindPayload) =>
@@ -357,7 +362,7 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
357362
const decoded = yield* decode(row);
358363
const key = textKey(decoded.item, cwd, input.skills ?? []);
359364
const segments = yield* Cache.get(
360-
key.text.length <= 32_768 ? textCache : largeTextCache,
365+
key.text.length <= 32_768 ? textCache.text : textCache.largeText,
361366
key,
362367
);
363368
const document = documentFor(decoded, countSegments(segments, input.query));

0 commit comments

Comments
 (0)