Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

fix(server): bound session listing and keep a full idle window after turns (#236)

Leo750749697daf
diff --git a/apps/server/src/provider/Layers/ProviderService.test.ts b/apps/server/src/provider/Layers/ProviderService.test.ts
index 893fd5761..aa414a78c 100644
--- a/apps/server/src/provider/Layers/ProviderService.test.ts
+++ b/apps/server/src/provider/Layers/ProviderService.test.ts
@@ -281,7 +281,11 @@ const hasMetricSnapshot = (
Object.entries(attributes).every(([key, value]) => snapshot.attributes?.[key] === value),
);
-function makeProviderServiceLayer() {
+function makeProviderServiceLayer(
+ input: {
+ readonly directory?: ProviderSessionDirectory.ProviderSessionDirectory["Service"];
+ } = {},
+) {
const codex = makeFakeCodexAdapter();
const claude = makeFakeCodexAdapter(CLAUDE_AGENT_DRIVER);
const cursor = makeFakeCodexAdapter(CURSOR_DRIVER);
@@ -298,7 +302,10 @@ function makeProviderServiceLayer() {
const runtimeRepositoryLayer = ProviderSessionRuntime.layer.pipe(
Layer.provide(SqlitePersistenceMemory),
);
- const directoryLayer = ProviderSessionDirectoryLive.pipe(Layer.provide(runtimeRepositoryLayer));
+ const directoryLayer =
+ input.directory === undefined
+ ? ProviderSessionDirectoryLive.pipe(Layer.provide(runtimeRepositoryLayer))
+ : Layer.succeed(ProviderSessionDirectory.ProviderSessionDirectory, input.directory);
const layer = it.layer(
Layer.mergeAll(
@@ -2117,6 +2124,53 @@ validation.layer("ProviderServiceLive validation", (it) => {
);
});
+const activeSessionThreadId = asThreadId("thread-active-session");
+const historicalSessionThreadId = asThreadId("thread-historical-session");
+const listThreadIds = vi.fn(() =>
+ Effect.succeed([activeSessionThreadId, historicalSessionThreadId]),
+);
+const getBinding = vi.fn((threadId: ThreadId) =>
+ Effect.succeed(
+ Option.some({
+ threadId,
+ provider: CODEX_DRIVER,
+ providerInstanceId: codexInstanceId,
+ }),
+ ),
+);
+const boundedListing = makeProviderServiceLayer({
+ directory: {
+ upsert: () => Effect.void,
+ getProvider: () => Effect.die("ProviderService.listSessions does not use getProvider"),
+ getBinding,
+ listThreadIds,
+ listBindings: () => Effect.die("ProviderService.listSessions does not use listBindings"),
+ },
+});
+
+boundedListing.layer("ProviderServiceLive session listing", (it) => {
+ it.effect("looks up bindings for active sessions without scanning historical threads", () =>
+ Effect.gen(function* () {
+ const provider = yield* ProviderService.ProviderService;
+ yield* boundedListing.codex.startSession({
+ provider: CODEX_DRIVER,
+ providerInstanceId: codexInstanceId,
+ threadId: activeSessionThreadId,
+ cwd: "/tmp/project-active-session",
+ runtimeMode: "full-access",
+ });
+ listThreadIds.mockClear();
+ getBinding.mockClear();
+
+ const sessions = yield* provider.listSessions();
+
+ assert.equal(sessions.length, 1);
+ assert.equal(listThreadIds.mock.calls.length, 0);
+ assert.deepEqual(getBinding.mock.calls, [[activeSessionThreadId]]);
+ }),
+ );
+});
+
describe("agent browser access", () => {
const revokedThreads: Array<ThreadId> = [];
diff --git a/apps/server/src/provider/Layers/ProviderService.ts b/apps/server/src/provider/Layers/ProviderService.ts
index 40c391da5..51ef9e048 100644
--- a/apps/server/src/provider/Layers/ProviderService.ts
+++ b/apps/server/src/provider/Layers/ProviderService.ts
@@ -938,21 +938,21 @@ const makeProviderService = Effect.fn("makeProviderService")(function* (
),
);
const activeSessions = sessionsByProvider.flatMap((sessions) => sessions);
- const persistedBindings = yield* directory.listThreadIds().pipe(
- Effect.flatMap((threadIds) =>
- Effect.forEach(
- threadIds,
- (threadId) =>
- directory
- .getBinding(threadId)
- .pipe(
- Effect.orElseSucceed(() =>
- Option.none<ProviderSessionDirectory.ProviderRuntimeBinding>(),
- ),
- ),
- { concurrency: "unbounded" },
- ),
- ),
+ // Only live adapter sessions appear in this response. Resolving every
+ // historical binding here makes each call scale with the full thread
+ // history instead of the active session set.
+ const persistedBindings = yield* Effect.forEach(
+ [...new Set(activeSessions.map((session) => session.threadId))],
+ (threadId) =>
+ directory
+ .getBinding(threadId)
+ .pipe(
+ Effect.orElseSucceed(() =>
+ Option.none<ProviderSessionDirectory.ProviderRuntimeBinding>(),
+ ),
+ ),
+ { concurrency: "unbounded" },
+ ).pipe(
Effect.orElseSucceed(
() => [] as Array<Option.Option<ProviderSessionDirectory.ProviderRuntimeBinding>>,
),
diff --git a/apps/server/src/provider/Layers/ProviderSessionReaper.test.ts b/apps/server/src/provider/Layers/ProviderSessionReaper.test.ts
index eee86dbc7..926d03929 100644
--- a/apps/server/src/provider/Layers/ProviderSessionReaper.test.ts
+++ b/apps/server/src/provider/Layers/ProviderSessionReaper.test.ts
@@ -1,6 +1,8 @@
import * as NodeServices from "@effect/platform-node/NodeServices";
import { ProjectId, ThreadId, TurnId, ProviderInstanceId } from "@t3tools/contracts";
+import * as Clock from "effect/Clock";
import * as DateTime from "effect/DateTime";
+import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Layer from "effect/Layer";
@@ -111,9 +113,35 @@ describe("ProviderSessionReaper", () => {
// Shared start sequence so each test adds no manual Effect runners
// (no-manual-effect-runtime-in-tests tracks this file's legacy count).
async function startReaper() {
- const reaper = await runtime!.runPromise(Effect.service(ProviderSessionReaper));
- scope = await Effect.runPromise(Scope.make("sequential"));
- await Effect.runPromise(reaper.start().pipe(Scope.provide(scope)));
+ await runtime!.runPromise(
+ Effect.gen(function* () {
+ const reaper = yield* ProviderSessionReaper;
+ scope = yield* Scope.make("sequential");
+ yield* reaper.start().pipe(Scope.provide(scope));
+ }),
+ );
+ }
+
+ async function sweepAt(nowMs: number) {
+ await runtime!.runPromise(
+ Effect.gen(function* () {
+ const reaper = yield* ProviderSessionReaper;
+ const clock = yield* Clock.Clock;
+ const swept = yield* Deferred.make<void>();
+ yield* reaper.start().pipe(
+ Effect.provideService(Clock.Clock, {
+ currentTimeMillis: Effect.succeed(nowMs),
+ currentTimeMillisUnsafe: () => nowMs,
+ currentTimeNanos: Effect.succeed(BigInt(nowMs) * 1_000_000n),
+ currentTimeNanosUnsafe: () => BigInt(nowMs) * 1_000_000n,
+ monotonicTimeNanos: clock.monotonicTimeNanos,
+ monotonicTimeNanosUnsafe: () => clock.monotonicTimeNanosUnsafe(),
+ sleep: () => Deferred.succeed(swept, undefined).pipe(Effect.andThen(Effect.never)),
+ }),
+ );
+ yield* Deferred.await(swept);
+ }).pipe(Effect.scoped),
+ );
}
async function createHarness(input: {
@@ -385,6 +413,105 @@ describe("ProviderSessionReaper", () => {
expect(Option.isSome(remaining)).toBe(true);
});
+ it.each(["ready", "interrupted", "error"] as const)(
+ "gives a long turn a full idle window after becoming %s",
+ async (status) => {
+ const threadId = ThreadId.make(`thread-reaper-long-turn-${status}`);
+ const startedAt = "2026-04-14T00:00:00.000Z";
+ const completedAt = "2026-04-14T01:00:00.000Z";
+ const completedAtMs = Date.parse(completedAt);
+ const harness = await createHarness({
+ readModel: makeReadModel([
+ {
+ id: threadId,
+ session: {
+ threadId,
+ status,
+ providerName: "claudeAgent",
+ runtimeMode: "full-access",
+ activeTurnId: null,
+ lastError: null,
+ updatedAt: completedAt,
+ },
+ },
+ ]),
+ });
+ const repository = await runtime!.runPromise(
+ Effect.service(ProviderSessionRuntime.ProviderSessionRuntimeRepository),
+ );
+ await runtime!.runPromise(
+ repository.upsert({
+ threadId,
+ providerName: "claudeAgent",
+ providerInstanceId: null,
+ adapterKey: "claudeAgent",
+ runtimeMode: "full-access",
+ status: "running",
+ lastSeenAt: startedAt,
+ resumeCursor: { opaque: "resume-long-turn" },
+ runtimePayload: null,
+ }),
+ );
+
+ await sweepAt(completedAtMs);
+ expect(harness.stopSession).not.toHaveBeenCalled();
+ await sweepAt(completedAtMs + 999);
+ expect(harness.stopSession).not.toHaveBeenCalled();
+ await sweepAt(completedAtMs + 1_000);
+ expect(harness.stopSession).toHaveBeenCalledTimes(1);
+ expect(harness.stopSession).toHaveBeenCalledWith({ threadId });
+ },
+ );
+
+ it.each([true, false])(
+ "uses the binding idle window when the session is older or missing, hasSession=%s",
+ async (hasSession) => {
+ const threadId = ThreadId.make("thread-reaper-fresh");
+ const now = "2026-04-14T01:00:00.000Z";
+ const nowMs = Date.parse(now);
+ const harness = await createHarness({
+ readModel: makeReadModel([
+ {
+ id: threadId,
+ session: hasSession
+ ? {
+ threadId,
+ status: "ready",
+ providerName: "claudeAgent",
+ runtimeMode: "full-access",
+ activeTurnId: null,
+ lastError: null,
+ updatedAt: "2026-04-14T00:00:00.000Z",
+ }
+ : null,
+ },
+ ]),
+ });
+ const repository = await runtime!.runPromise(
+ Effect.service(ProviderSessionRuntime.ProviderSessionRuntimeRepository),
+ );
+ await runtime!.runPromise(
+ repository.upsert({
+ threadId,
+ providerName: "claudeAgent",
+ providerInstanceId: null,
+ adapterKey: "claudeAgent",
+ runtimeMode: "full-access",
+ status: "running",
+ lastSeenAt: now,
+ resumeCursor: { opaque: "resume-fresh" },
+ runtimePayload: null,
+ }),
+ );
+
+ await sweepAt(nowMs + 999);
+ expect(harness.stopSession).not.toHaveBeenCalled();
+ await sweepAt(nowMs + 1_000);
+ expect(harness.stopSession).toHaveBeenCalledTimes(1);
+ expect(harness.stopSession).toHaveBeenCalledWith({ threadId });
+ },
+ );
+
it("skips persisted sessions that are already marked stopped", async () => {
const threadId = ThreadId.make("thread-reaper-stopped");
const now = "2026-01-01T00:00:00.000Z";
diff --git a/apps/server/src/provider/Layers/ProviderSessionReaper.ts b/apps/server/src/provider/Layers/ProviderSessionReaper.ts
index 83124b2e1..676343bc5 100644
--- a/apps/server/src/provider/Layers/ProviderSessionReaper.ts
+++ b/apps/server/src/provider/Layers/ProviderSessionReaper.ts
@@ -54,14 +54,24 @@ const makeProviderSessionReaper = (options?: ProviderSessionReaperLiveOptions) =
continue;
}
- const idleDurationMs = now - lastSeenMs;
- if (idleDurationMs < inactivityThresholdMs) {
+ if (now - lastSeenMs < inactivityThresholdMs) {
continue;
}
const thread = yield* projectionSnapshotQuery
.getThreadShellById(binding.threadId)
.pipe(Effect.map(Option.getOrUndefined));
+ // Ingestion updates this timestamp alongside activeTurnId when a turn
+ // settles. Long turns must get a full idle window after that transition,
+ // even though the binding was last touched when the turn was sent.
+ const lastActivityMs = Math.max(
+ lastSeenMs,
+ Date.parse(thread?.session?.updatedAt ?? binding.lastSeenAt),
+ );
+ const idleDurationMs = now - lastActivityMs;
+ if (idleDurationMs < inactivityThresholdMs) {
+ continue;
+ }
if (thread?.session?.activeTurnId != null) {
yield* Effect.logDebug("provider.session.reaper.skipped-active-turn", {
threadId: binding.threadId,