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.tsindex 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.tsindex 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.tsindex 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.tsindex 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,