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.

perf: run chats on per-thread lanes and cut repeated streaming work (#291)

Leo5ff172b8d6ed
diff --git a/.changeset/calm-chats-progress.md b/.changeset/calm-chats-progress.md
new file mode 100644
index 000000000..7870c11f3
--- /dev/null
+++ b/.changeset/calm-chats-progress.md
@@ -0,0 +1,6 @@
+---
+"akeru-bot": patch
+"@akeru/web": patch
+---
+
+Keep independent chats responsive during provider setup and workspace refreshes, and avoid repeated work during streaming updates.
diff --git a/apps/mobile/src/lib/threadActivity.test.ts b/apps/mobile/src/lib/threadActivity.test.ts
index 7208b55e7..a975289ad 100644
--- a/apps/mobile/src/lib/threadActivity.test.ts
+++ b/apps/mobile/src/lib/threadActivity.test.ts
@@ -19,6 +19,7 @@ import {
import {
buildPendingUserInputAnswers,
buildThreadFeed,
+ createThreadFeedBuilder,
deriveGroupSpeakerLabels,
derivePendingApprovals,
deriveThreadFeedPresentation,
@@ -360,6 +361,79 @@ describe("buildThreadFeed", () => {
]);
});
+ it("keeps the selected feed stable across metadata and unrelated feedback updates", () => {
+ const buildFeed = createThreadFeedBuilder();
+ const thread = makeThread({
+ id: ThreadId.make("thread-feed-memo"),
+ projectId: ProjectId.make("project-1"),
+ title: "Before",
+ });
+ const submissions = {
+ selected: [],
+ other: [],
+ };
+ const first = buildFeed(thread, { localMessages: submissions.selected });
+ const updated = { ...submissions, other: [{ text: "Other chat feedback" }] };
+ const renamed = { ...thread, title: "After" };
+ expect(buildFeed(renamed, { localMessages: updated.selected })).toBe(first);
+ expect(
+ buildFeed(
+ { ...thread, activities: [...thread.activities] },
+ {
+ localMessages: updated.selected,
+ },
+ ),
+ ).not.toBe(first);
+ });
+
+ it("reuses activity-derived step meters across message deltas and invalidates new activity", () => {
+ const turnId = TurnId.make("turn-meter-cache");
+ const payload = {
+ botId: BotId.make("bot-meter-cache"),
+ engine: { provider: "codex", model: "gpt-5.4" },
+ tokens: 10,
+ estimatedCost: { status: "available", usd: 0.01 },
+ };
+ const activity = makeActivity({
+ id: EventId.make("meter-cache"),
+ kind: "bot.step-usage.updated",
+ summary: "Step usage",
+ createdAt: "2026-08-31T00:00:01.000Z",
+ turnId,
+ payload,
+ });
+ const activities = [activity];
+ const base = {
+ id: ThreadId.make("thread-meter-cache"),
+ projectId: ProjectId.make("project-1"),
+ title: "Meter cache",
+ };
+ const message = {
+ id: MessageId.make("meter-cache-reply"),
+ role: "assistant" as const,
+ text: "Working",
+ turnId,
+ streaming: true,
+ createdAt: "2026-08-31T00:00:02.000Z",
+ updatedAt: "2026-08-31T00:00:02.000Z",
+ };
+ const first = buildThreadFeed(makeThread({ ...base, activities, messages: [message] }));
+ const delta = { ...message, text: "Working on it" };
+ const second = buildThreadFeed(makeThread({ ...base, activities, messages: [delta] }));
+ const firstReply = first.find((entry) => entry.type === "message");
+ const secondReply = second.find((entry) => entry.type === "message");
+ expect(firstReply?.botStepMeter).toBeDefined();
+ expect(secondReply?.botStepMeter).toBe(firstReply?.botStepMeter);
+
+ const updated = { ...activity, payload: { ...payload, tokens: 20 } };
+ const third = buildThreadFeed(
+ makeThread({ ...base, activities: [updated], messages: [delta] }),
+ );
+ expect(third.find((entry) => entry.type === "message")?.botStepMeter).not.toBe(
+ secondReply?.botStepMeter,
+ );
+ });
+
it("keeps unchanged rows referentially stable while a turn streams", () => {
const turnId = TurnId.make("turn-stream");
const user = {
@@ -1148,6 +1222,29 @@ describe("delegation cards in the feed", () => {
assistantMessage("bot-3", 22, "turn-3"),
];
+ it("invalidates the cached feed when delegation cards or local messages change", () => {
+ const buildFeed = createThreadFeedBuilder();
+ const thread = feedThread(messages);
+ const delegation = feedDelegation("d-cache", 2, "turn-1", "user-1");
+ const initial = buildFeed(thread);
+ const carded = buildFeed(thread, { delegations: [delegation] });
+ expect(carded).not.toBe(initial);
+ expect(carded.some((entry) => entry.type === "delegation")).toBe(true);
+ expect(buildFeed(thread, { delegations: [delegation] })).toBe(carded);
+ const updated = { ...delegation, task: "Updated task" };
+ const changed = buildFeed(thread, { delegations: [updated] });
+ expect(changed).not.toBe(carded);
+ expect(changed.find((entry) => entry.type === "delegation")?.delegation.task).toBe(
+ "Updated task",
+ );
+ expect(
+ buildFeed(thread, {
+ delegations: [updated],
+ localMessages: [userMessage("local-feedback", 30)],
+ }),
+ ).not.toBe(changed);
+ });
+
it("matches botChatTimeline order for three turns", () => {
const feed = buildThreadFeed(feedThread(messages), {
delegations: [
diff --git a/apps/mobile/src/lib/threadActivity.ts b/apps/mobile/src/lib/threadActivity.ts
index 9b77761a4..e4ec49c17 100644
--- a/apps/mobile/src/lib/threadActivity.ts
+++ b/apps/mobile/src/lib/threadActivity.ts
@@ -1454,8 +1454,35 @@ function withoutCardedDelegationActivities(
});
}
+const activityFeedDerivations = new WeakMap<
+ ReadonlyArray<OrchestrationThreadActivity>,
+ {
+ readonly delegations: ReadonlyArray<AkeruDelegationRecord>;
+ readonly botStepMeters: ReturnType<typeof buildBotStepMeters>;
+ readonly workLogEntries: ReturnType<typeof deriveWorkLogEntries>;
+ }
+>();
+const NO_FEED_DELEGATIONS: ReadonlyArray<AkeruDelegationRecord> = Object.freeze([]);
+
+function deriveActivityFeed(
+ activities: ReadonlyArray<OrchestrationThreadActivity>,
+ delegations: ReadonlyArray<AkeruDelegationRecord>,
+) {
+ const cached = activityFeedDerivations.get(activities);
+ if (cached !== undefined && sameEntries(cached.delegations, delegations)) return cached;
+ const derivation = {
+ delegations,
+ botStepMeters: buildBotStepMeters(activities),
+ workLogEntries: deriveWorkLogEntries(
+ withoutCardedDelegationActivities(activities, delegations),
+ ),
+ };
+ activityFeedDerivations.set(activities, derivation);
+ return derivation;
+}
+
export function buildThreadFeed(
- thread: OrchestrationThread,
+ thread: Pick<OrchestrationThread, "messages" | "activities">,
options?: {
readonly loadedMessages?: ReadonlyArray<OrchestrationThread["messages"][number]>;
readonly localMessages?: ReadonlyArray<OrchestrationThread["messages"][number]>;
@@ -1489,9 +1516,9 @@ export function buildThreadFeed(
}
const oldestLoadedMessageCreatedAt =
options?.loadedMessages !== undefined ? (loadedMessages[0]?.createdAt ?? null) : null;
- const botStepMeters = buildBotStepMeters(thread.activities);
- const workLogEntries = deriveWorkLogEntries(
- withoutCardedDelegationActivities(thread.activities, options?.delegations ?? []),
+ const { botStepMeters, workLogEntries } = deriveActivityFeed(
+ thread.activities,
+ options?.delegations ?? NO_FEED_DELEGATIONS,
);
const timed: Array<{ readonly at: number; readonly entry: RawThreadFeedEntry }> = [];
for (const message of messages) {
@@ -1524,6 +1551,45 @@ export function buildThreadFeed(
);
}
+export function createThreadFeedBuilder() {
+ let previous:
+ | {
+ readonly messages: OrchestrationThread["messages"];
+ readonly activities: OrchestrationThread["activities"];
+ readonly loadedMessages: ReadonlyArray<OrchestrationThread["messages"][number]> | undefined;
+ readonly localMessages: ReadonlyArray<OrchestrationThread["messages"][number]> | undefined;
+ readonly delegations: ReadonlyArray<AkeruDelegationRecord>;
+ readonly feed: ThreadFeedEntry[];
+ }
+ | undefined;
+ return (
+ thread: Pick<OrchestrationThread, "messages" | "activities">,
+ options?: Parameters<typeof buildThreadFeed>[1],
+ ): ThreadFeedEntry[] => {
+ const delegations = options?.delegations ?? NO_FEED_DELEGATIONS;
+ if (
+ previous !== undefined &&
+ previous.messages === thread.messages &&
+ previous.activities === thread.activities &&
+ previous.loadedMessages === options?.loadedMessages &&
+ previous.localMessages === options?.localMessages &&
+ sameEntries(previous.delegations, delegations)
+ ) {
+ return previous.feed;
+ }
+ const feed = buildThreadFeed(thread, options);
+ previous = {
+ messages: thread.messages,
+ activities: thread.activities,
+ loadedMessages: options?.loadedMessages,
+ localMessages: options?.localMessages,
+ delegations,
+ feed,
+ };
+ return feed;
+ };
+}
+
/** Same ordering as `Order.Date`: stable ties, unparsable times first. */
function compareFeedTimes(left: number, right: number): number {
if (left === right) return 0;
diff --git a/apps/mobile/src/state/thread-selection.test.ts b/apps/mobile/src/state/thread-selection.test.ts
new file mode 100644
index 000000000..efe9138be
--- /dev/null
+++ b/apps/mobile/src/state/thread-selection.test.ts
@@ -0,0 +1,21 @@
+import { describe, expect, it } from "vite-plus/test";
+
+import { EnvironmentId, ThreadId } from "@akeru/contracts";
+
+import { resolveThreadSelectionDetailRef } from "./thread-selection";
+
+const selectedThreadRef = {
+ environmentId: EnvironmentId.make("environment-1"),
+ threadId: ThreadId.make("thread-1"),
+};
+
+describe("resolveThreadSelectionDetailRef", () => {
+ it("uses the empty detail target when a shell is available", () => {
+ expect(resolveThreadSelectionDetailRef(selectedThreadRef, true)).toBeNull();
+ });
+
+ it("keeps the detail fallback for shell-absent deep links", () => {
+ expect(resolveThreadSelectionDetailRef(selectedThreadRef, false)).toBe(selectedThreadRef);
+ expect(resolveThreadSelectionDetailRef(null, false)).toBeNull();
+ });
+});
diff --git a/apps/mobile/src/state/thread-selection.ts b/apps/mobile/src/state/thread-selection.ts
new file mode 100644
index 000000000..dcf939d09
--- /dev/null
+++ b/apps/mobile/src/state/thread-selection.ts
@@ -0,0 +1,8 @@
+import type { ScopedThreadRef } from "@akeru/contracts";
+
+export function resolveThreadSelectionDetailRef(
+ selectedThreadRef: ScopedThreadRef | null,
+ hasSelectedThreadShell: boolean,
+): ScopedThreadRef | null {
+ return hasSelectedThreadShell ? null : selectedThreadRef;
+}
diff --git a/apps/mobile/src/state/use-thread-composer-state.ts b/apps/mobile/src/state/use-thread-composer-state.ts
index cb3fb7aae..f909921ce 100644
--- a/apps/mobile/src/state/use-thread-composer-state.ts
+++ b/apps/mobile/src/state/use-thread-composer-state.ts
@@ -33,7 +33,7 @@ import { scopedThreadKey } from "../lib/scopedEntities";
import { copyTextWithHaptic } from "../lib/copyTextWithHaptic";
import { useMobileI18n } from "../lib/i18n";
import {
- buildThreadFeed,
+ createThreadFeedBuilder,
deriveThreadFeedDelegations,
unchangedPrefixLength,
type ThreadFeedDelegations,
@@ -78,6 +78,8 @@ export function useThreadDraftForThread(input: {
};
}
+const EMPTY_FEEDBACK_SUBMISSIONS: ReadonlyArray<CodexFeedbackSubmission> = Object.freeze([]);
+
const feedDelegationsAtom = Atom.family((key: string) => {
const [environmentId, threadId] = key.split("\n") as [
EnvironmentId | undefined,
@@ -97,6 +99,7 @@ export function useThreadComposerState() {
const { t } = useMobileI18n();
const { selectedThread: selectedThreadShell, selectedEnvironmentRuntime } = useThreadSelection();
const selectedThreadDetail = useSelectedThreadDetail();
+ const buildSelectedThreadFeed = useMemo(() => createThreadFeedBuilder(), []);
const openedAuthorizationActivitiesRef = useRef(new Set<string>());
const queuedMessagesByThreadKey = useThreadOutboxMessages();
const [feedbackSubmissionsByThreadKey, setFeedbackSubmissionsByThreadKey] = useState<
@@ -155,27 +158,35 @@ export function useThreadComposerState() {
() => JSON.parse(selectedThreadDelegations) as ThreadFeedDelegations,
[selectedThreadDelegations],
);
- const selectedThreadFeed = useMemo(() => {
- if (!selectedThreadDetail) {
- return [];
- }
- const submissions = selectedThreadKey
- ? (feedbackSubmissionsByThreadKey[selectedThreadKey] ?? [])
- : [];
- const { delegations } = selectedThreadFeedDelegations;
- return buildThreadFeed(selectedThreadDetail, {
- localMessages: submissions.flatMap((submission) =>
+ const selectedThreadFeedbackSubmissions = selectedThreadKey
+ ? (feedbackSubmissionsByThreadKey[selectedThreadKey] ?? EMPTY_FEEDBACK_SUBMISSIONS)
+ : EMPTY_FEEDBACK_SUBMISSIONS;
+ const selectedThreadLocalMessages = useMemo(
+ () =>
+ selectedThreadFeedbackSubmissions.flatMap((submission) =>
submission.status === "interrupted"
? []
: [codexFeedbackMessage(submission), codexFeedbackMessage(submission, "assistant")],
),
- delegations,
- });
+ [selectedThreadFeedbackSubmissions],
+ );
+ const selectedThreadActivities = selectedThreadDetail?.activities;
+ const selectedThreadMessages = selectedThreadDetail?.messages;
+ const selectedThreadFeed = useMemo(() => {
+ if (!selectedThreadActivities || !selectedThreadMessages) return [];
+ return buildSelectedThreadFeed(
+ { activities: selectedThreadActivities, messages: selectedThreadMessages },
+ {
+ localMessages: selectedThreadLocalMessages,
+ delegations: selectedThreadFeedDelegations.delegations,
+ },
+ );
}, [
- feedbackSubmissionsByThreadKey,
+ buildSelectedThreadFeed,
+ selectedThreadActivities,
+ selectedThreadMessages,
+ selectedThreadLocalMessages,
selectedThreadFeedDelegations,
- selectedThreadDetail,
- selectedThreadKey,
]);
// Draft text and attachments are read by the composer itself, so typing
diff --git a/apps/mobile/src/state/use-thread-selection.ts b/apps/mobile/src/state/use-thread-selection.ts
index 0553a71b5..8ac372218 100644
--- a/apps/mobile/src/state/use-thread-selection.ts
+++ b/apps/mobile/src/state/use-thread-selection.ts
@@ -16,6 +16,7 @@ import {
useRemoteEnvironmentRuntime,
useSavedRemoteConnection,
} from "./use-remote-environment-registry";
+import { resolveThreadSelectionDetailRef } from "./thread-selection";
type ThreadSelectionRouteParams = {
readonly environmentId?: string | string[];
readonly threadId?: string | string[];
@@ -93,9 +94,13 @@ function useResolvedThreadSelection(params: ThreadSelectionRouteParams | undefin
}
const selectedThreadRef = routeThreadRef ?? lastRouteThreadRef.current;
const selectedThreadShell = useThreadShell(selectedThreadRef);
+ const selectedThreadDetailRef = resolveThreadSelectionDetailRef(
+ selectedThreadRef,
+ selectedThreadShell !== null,
+ );
const selectedThreadDetailState = useEnvironmentThread(
- selectedThreadRef?.environmentId ?? null,
- selectedThreadRef?.threadId ?? null,
+ selectedThreadDetailRef?.environmentId ?? null,
+ selectedThreadDetailRef?.threadId ?? null,
);
const selectedThreadDetail = Option.getOrNull(selectedThreadDetailState.data);
const selectedThread = useMemo(
diff --git a/apps/server/src/composio/ComposioService.test.ts b/apps/server/src/composio/ComposioService.test.ts
index 3dcf0db75..14fbf0d78 100644
--- a/apps/server/src/composio/ComposioService.test.ts
+++ b/apps/server/src/composio/ComposioService.test.ts
@@ -234,6 +234,62 @@ describe("ComposioService", () => {
}),
);
+ it.effect("reuses a hosted runtime when account and toolkit order changes", () =>
+ Effect.gen(function* () {
+ const { store } = makeSecretStore({ "composio-api-key": "project-key" });
+ const { client, createSession, sessionDeletes } = fakeClient({
+ accounts: [
+ { id: "gmail-work", toolkit: { slug: "gmail" }, status: "ACTIVE" },
+ { id: "slack-work", toolkit: { slug: "slack" }, status: "ACTIVE" },
+ { id: "gmail-home", toolkit: { slug: "gmail" }, status: "ACTIVE" },
+ ],
+ });
+ const service = make(store, () => client);
+
+ const first = yield* service.resolveRuntimeMcpServer("thread-1");
+ vi.mocked(client.connectedAccounts.list).mockResolvedValue({
+ items: [
+ { id: "gmail-home", toolkit: { slug: "gmail" }, status: "ACTIVE" },
+ { id: "gmail-work", toolkit: { slug: "gmail" }, status: "ACTIVE" },
+ { id: "slack-work", toolkit: { slug: "slack" }, status: "ACTIVE" },
+ ],
+ totalPages: 1,
+ } as never);
+ const reordered = yield* service.resolveRuntimeMcpServer("thread-1");
+
+ expect(reordered).toBe(first);
+ expect(createSession).toHaveBeenCalledTimes(1);
+ expect(sessionDeletes[0]).not.toHaveBeenCalled();
+ }),
+ );
+
+ it.effect("replaces a hosted runtime when active account status changes", () =>
+ Effect.gen(function* () {
+ const { store } = makeSecretStore({ "composio-api-key": "project-key" });
+ const { client, createSession, sessionDeletes } = fakeClient({
+ accounts: [
+ { id: "gmail-work", toolkit: { slug: "gmail" }, status: "ACTIVE" },
+ { id: "gmail-home", toolkit: { slug: "gmail" }, status: "ACTIVE" },
+ ],
+ });
+ const service = make(store, () => client);
+
+ yield* service.resolveRuntimeMcpServer("thread-1");
+ vi.mocked(client.connectedAccounts.list).mockResolvedValue({
+ items: [
+ { id: "gmail-work", toolkit: { slug: "gmail" }, status: "ACTIVE" },
+ { id: "gmail-home", toolkit: { slug: "gmail" }, status: "FAILED" },
+ ],
+ totalPages: 1,
+ } as never);
+ yield* service.resolveRuntimeMcpServer("thread-1");
+
+ expect(createSession).toHaveBeenCalledTimes(2);
+ expect(sessionDeletes[0]).toHaveBeenCalledTimes(1);
+ expect(sessionDeletes[1]).not.toHaveBeenCalled();
+ }),
+ );
+
it.effect("deletes a hosted session before replacing its cached runtime", () =>
Effect.gen(function* () {
const { store } = makeSecretStore({ "composio-api-key": "project-key" });
diff --git a/apps/server/src/composio/ComposioService.ts b/apps/server/src/composio/ComposioService.ts
index 6b12ec243..08c103fe6 100644
--- a/apps/server/src/composio/ComposioService.ts
+++ b/apps/server/src/composio/ComposioService.ts
@@ -331,7 +331,11 @@ export function make(
(accounts ?? []).map((account) => account.id),
]),
);
- const fingerprint = JSON.stringify(accountMap);
+ const fingerprint = JSON.stringify(
+ Object.entries(accountMap)
+ .sort(([left], [right]) => left.localeCompare(right))
+ .map(([toolkit, accountIds]) => [toolkit, [...accountIds].sort()]),
+ );
const cached = runtimeCache.get(resourceId);
if (cached?.fingerprint === fingerprint) return cached.server;
await deleteCachedSession(resourceId);
diff --git a/apps/server/src/orchestration/Layers/ProviderCommandReactor.keyed-worker.test.ts b/apps/server/src/orchestration/Layers/ProviderCommandReactor.keyed-worker.test.ts
new file mode 100644
index 000000000..cf0d13ec2
--- /dev/null
+++ b/apps/server/src/orchestration/Layers/ProviderCommandReactor.keyed-worker.test.ts
@@ -0,0 +1,142 @@
+import { it } from "@effect/vitest";
+import { describe, expect } from "vite-plus/test";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+
+import { makeKeyedDrainableWorker } from "./ProviderCommandReactor.ts";
+
+describe("makeKeyedDrainableWorker", () => {
+ it.effect(
+ "runs independent keys while preserving same-thread start, stop, and restart FIFO",
+ () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const startedA1 = yield* Deferred.make<void>();
+ const releaseA1 = yield* Deferred.make<void>();
+ const startedB1 = yield* Deferred.make<void>();
+ const processed: string[] = [];
+ const worker = yield* makeKeyedDrainableWorker<string, string, never, never>({
+ concurrency: 2,
+ process: (item) =>
+ Effect.gen(function* () {
+ if (item === "start") {
+ yield* Deferred.succeed(startedA1, undefined).pipe(Effect.orDie);
+ yield* Deferred.await(releaseA1);
+ }
+ if (item === "approval") {
+ processed.push(item);
+ yield* Deferred.succeed(startedB1, undefined).pipe(Effect.orDie);
+ return;
+ }
+ processed.push(item);
+ }),
+ });
+
+ yield* worker.enqueue("thread-a", "start");
+ yield* worker.enqueue("thread-a", "stop");
+ yield* worker.enqueue("thread-a", "restart");
+ yield* worker.enqueue("thread-b", "approval");
+ yield* Deferred.await(startedA1);
+ yield* Deferred.await(startedB1);
+
+ expect(processed).toEqual(["approval"]);
+ yield* Deferred.succeed(releaseA1, undefined);
+ yield* worker.drain;
+ expect(processed).toEqual(["approval", "start", "stop", "restart"]);
+ }),
+ ),
+ );
+
+ it.effect("drain awaits active and queued work across lanes", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const startedA = yield* Deferred.make<void>();
+ const startedB = yield* Deferred.make<void>();
+ const releaseA = yield* Deferred.make<void>();
+ const releaseB = yield* Deferred.make<void>();
+ const drained = yield* Deferred.make<void>();
+ const worker = yield* makeKeyedDrainableWorker<string, string, never, never>({
+ concurrency: 2,
+ process: (item) =>
+ Effect.gen(function* () {
+ const started = item.startsWith("a") ? startedA : startedB;
+ const release = item.startsWith("a") ? releaseA : releaseB;
+ yield* Deferred.succeed(started, undefined).pipe(Effect.ignore);
+ yield* Deferred.await(release);
+ }),
+ });
+
+ yield* worker.enqueue("a", "a1");
+ yield* worker.enqueue("a", "a2");
+ yield* worker.enqueue("b", "b1");
+ yield* Deferred.await(startedA);
+ yield* Deferred.await(startedB);
+ yield* Effect.forkChild(
+ worker.drain.pipe(Effect.andThen(Deferred.succeed(drained, undefined)), Effect.asVoid),
+ );
+
+ yield* Deferred.succeed(releaseB, undefined);
+ expect(yield* Deferred.isDone(drained)).toBe(false);
+ yield* Deferred.succeed(releaseA, undefined);
+ yield* Deferred.await(drained);
+ }),
+ ),
+ );
+
+ it.effect("enforces its limit and continues a lane after failure", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const started = new Map<string, Deferred.Deferred<void>>();
+ const releases = new Map<string, Deferred.Deferred<void>>();
+ for (const item of ["a", "b", "c"]) {
+ started.set(item, yield* Deferred.make<void>());
+ releases.set(item, yield* Deferred.make<void>());
+ }
+ const recovered = yield* Deferred.make<void>();
+ let active = 0;
+ let maxActive = 0;
+ const worker = yield* makeKeyedDrainableWorker<string, string, string, never>({
+ concurrency: 2,
+ process: (item) =>
+ item === "fail"
+ ? Effect.fail("injected failure")
+ : item === "recovered"
+ ? Deferred.succeed(recovered, undefined).pipe(Effect.asVoid)
+ : Effect.acquireUseRelease(
+ Effect.sync(() => {
+ active += 1;
+ maxActive = Math.max(maxActive, active);
+ }),
+ () =>
+ Effect.gen(function* () {
+ yield* Deferred.succeed(started.get(item)!, undefined).pipe(Effect.orDie);
+ yield* Deferred.await(releases.get(item)!);
+ }),
+ () =>
+ Effect.sync(() => {
+ active -= 1;
+ }),
+ ),
+ });
+
+ yield* worker.enqueue("a", "a");
+ yield* worker.enqueue("b", "b");
+ yield* worker.enqueue("c", "c");
+ yield* worker.enqueue("recovery", "fail");
+ yield* worker.enqueue("recovery", "recovered");
+ yield* Deferred.await(started.get("a")!);
+ yield* Deferred.await(started.get("b")!);
+ expect(yield* Deferred.isDone(started.get("c")!)).toBe(false);
+ expect(maxActive).toBe(2);
+
+ yield* Deferred.succeed(releases.get("a")!, undefined);
+ yield* Deferred.await(started.get("c")!);
+ yield* Deferred.succeed(releases.get("b")!, undefined);
+ yield* Deferred.succeed(releases.get("c")!, undefined);
+ yield* Deferred.await(recovered);
+ yield* worker.drain;
+ expect(maxActive).toBe(2);
+ }),
+ ),
+ );
+});
diff --git a/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts b/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts
index 60fe58ce2..ab15c205c 100644
--- a/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts
+++ b/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts
@@ -222,8 +222,13 @@ describe("ProviderCommandReactor", () => {
readonly titleUpdatesBeforeStartupCommit?: number;
readonly failStartupReplay?: boolean;
readonly pendingRequestBeforeReactor?: "approval" | "user-input";
- readonly interruptTurnEffect?: () => Effect.Effect<void, ProviderAdapterRequestError>;
+ readonly interruptTurnEffect?: (
+ input?: unknown,
+ ) => Effect.Effect<void, ProviderAdapterRequestError>;
readonly interruptTurnRemovesSession?: boolean;
+ readonly respondToRequestEffect?: (
+ input: Parameters<AgentControllerShape["respondToRequest"]>[0],
+ ) => Effect.Effect<void, ProviderAdapterRequestError>;
readonly stopSessionEffect?: () => Effect.Effect<void, ProviderAdapterRequestError>;
readonly startSessionEffect?: (
session: ProviderSession,
@@ -330,7 +335,7 @@ describe("ProviderCommandReactor", () => {
}),
);
const interruptTurn = vi.fn((interruptInput: unknown) =>
- (input?.interruptTurnEffect?.() ?? Effect.void).pipe(
+ (input?.interruptTurnEffect?.(interruptInput) ?? Effect.void).pipe(
Effect.tap(() =>
Effect.sync(() => {
if (input?.interruptTurnRemovesSession !== true) {
@@ -353,7 +358,9 @@ describe("ProviderCommandReactor", () => {
),
),
);
- const respondToRequest = vi.fn<AgentControllerShape["respondToRequest"]>(() => Effect.void);
+ const respondToRequest = vi.fn<AgentControllerShape["respondToRequest"]>(
+ (request) => input?.respondToRequestEffect?.(request) ?? Effect.void,
+ );
const respondToUserInput = vi.fn<AgentControllerShape["respondToUserInput"]>(() => Effect.void);
const stopSession = vi.fn((stopInput: unknown) =>
(input?.stopSessionEffect?.() ?? Effect.void).pipe(
@@ -1074,6 +1081,108 @@ describe("ProviderCommandReactor", () => {
).rejects.toThrow("Injected startup replay failure");
});
+ effectIt.effect("lets another thread approve and interrupt while session setup is blocked", () =>
+ Effect.gen(function* () {
+ const sessionSetupStarted = yield* Deferred.make<void>();
+ const releaseSessionSetup = yield* Deferred.make<void>();
+ const approvalReachedAdapter = yield* Deferred.make<void>();
+ const interruptReachedAdapter = yield* Deferred.make<void>();
+ const threadB = ThreadId.make("thread-2");
+ const harness = yield* Effect.promise(() =>
+ createHarness({
+ startSessionEffect: (session) =>
+ session.threadId === ThreadId.make("thread-1")
+ ? Deferred.succeed(sessionSetupStarted, undefined).pipe(
+ Effect.andThen(Deferred.await(releaseSessionSetup)),
+ Effect.as(session),
+ )
+ : Effect.succeed(session),
+ respondToRequestEffect: (request) =>
+ request.threadId === threadB
+ ? Deferred.succeed(approvalReachedAdapter, undefined).pipe(Effect.asVoid)
+ : Effect.void,
+ interruptTurnEffect: (request) =>
+ typeof request === "object" &&
+ request !== null &&
+ "threadId" in request &&
+ request.threadId === threadB
+ ? Deferred.succeed(interruptReachedAdapter, undefined).pipe(Effect.asVoid)
+ : Effect.void,
+ }),
+ );
+ const now = "2026-01-01T00:00:00.000Z";
+
+ yield* harness.engine.dispatch({
+ type: "thread.create",
+ commandId: CommandId.make("cmd-thread-create-2-concurrency"),
+ threadId: threadB,
+ projectId: asProjectId("project-1"),
+ title: "Thread B",
+ modelSelection: {
+ instanceId: ProviderInstanceId.make("codex"),
+ model: "gpt-5-codex",
+ },
+ interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
+ runtimeMode: "approval-required",
+ branch: null,
+ worktreePath: null,
+ createdAt: now,
+ });
+ yield* harness.engine.dispatch({
+ type: "thread.session.set",
+ commandId: CommandId.make("cmd-thread-session-2-concurrency"),
+ threadId: threadB,
+ session: {
+ threadId: threadB,
+ status: "running",
+ providerName: "codex",
+ runtimeMode: "approval-required",
+ activeTurnId: asTurnId("turn-2"),
+ lastError: null,
+ updatedAt: now,
+ },
+ createdAt: now,
+ });
+ yield* harness.engine.dispatch({
+ type: "thread.turn.start",
+ commandId: CommandId.make("cmd-turn-start-blocked-thread-1"),
+ threadId: ThreadId.make("thread-1"),
+ message: {
+ messageId: asMessageId("user-message-blocked-thread-1"),
+ role: "user",
+ text: "block this setup",
+ attachments: [],
+ },
+ interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
+ runtimeMode: "approval-required",
+ createdAt: now,
+ });
+ yield* Deferred.await(sessionSetupStarted);
+
+ yield* harness.engine.dispatch({
+ type: "thread.approval.respond",
+ commandId: CommandId.make("cmd-approval-thread-2-concurrency"),
+ threadId: threadB,
+ requestId: asApprovalRequestId("approval-thread-2-concurrency"),
+ decision: "accept",
+ createdAt: now,
+ });
+ yield* harness.engine.dispatch({
+ type: "thread.turn.interrupt",
+ commandId: CommandId.make("cmd-interrupt-thread-2-concurrency"),
+ threadId: threadB,
+ turnId: asTurnId("turn-2"),
+ createdAt: now,
+ });
+
+ yield* Deferred.await(approvalReachedAdapter);
+ yield* Deferred.await(interruptReachedAdapter);
+ expect(yield* Deferred.isDone(releaseSessionSetup)).toBe(false);
+ yield* Deferred.succeed(releaseSessionSetup, undefined);
+ yield* Effect.promise(() => harness.drain());
+ }),
+ );
+
it("replays a persisted turn start that predates reactor startup exactly once", async () => {
const harness = await createHarness({ turnStartBeforeReactor: true });
@@ -4831,7 +4940,7 @@ describe("ProviderCommandReactor", () => {
keep: false,
createdAt: later,
});
- yield* Effect.promise(() => waitFor(() => harness.interruptTurn.mock.calls.length === 1));
+ yield* Effect.promise(() => harness.drain());
expect(harness.interruptTurn).toHaveBeenCalledWith({
threadId: canceled.childThreadId,
turnId: canceled.childTurnId,
diff --git a/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts b/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts
index 98b1c0131..d6d6395c5 100644
--- a/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts
+++ b/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts
@@ -54,7 +54,10 @@ import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Schedule from "effect/Schedule";
import * as Schema from "effect/Schema";
+import * as Scope from "effect/Scope";
import * as Stream from "effect/Stream";
+import * as TxQueue from "effect/TxQueue";
+import * as TxRef from "effect/TxRef";
import * as SubscriptionRef from "effect/SubscriptionRef";
import { makeDrainableWorker } from "@akeru/shared/DrainableWorker";
@@ -180,6 +183,102 @@ const MANUAL_RECOVERY_INPUT = [
].join(" ");
const THREAD_TITLE_CONTEXT_TRUNCATION_MARKER = "[Earlier content truncated]\n\n";
const FIRST_USER_CONTEXT_TRUNCATION_MARKER = "\n[First user message truncated]";
+const PROVIDER_COMMAND_CONCURRENCY = 4;
+
+export interface KeyedDrainableWorker<K, A> {
+ readonly enqueue: (key: K, item: A) => Effect.Effect<void>;
+ readonly drain: Effect.Effect<void>;
+}
+
+interface KeyedDrainableWorkerState<K, A> {
+ readonly lanes: Map<K, ReadonlyArray<A>>;
+ readonly outstanding: number;
+}
+
+export const makeKeyedDrainableWorker = <K, A, E, R>(options: {
+ readonly concurrency: number;
+ readonly process: (item: A) => Effect.Effect<void, E, R>;
+}): Effect.Effect<KeyedDrainableWorker<K, A>, never, Scope.Scope | R> =>
+ Effect.gen(function* () {
+ const concurrency = Math.max(1, Math.floor(options.concurrency));
+ const readyKeys = yield* Effect.acquireRelease(TxQueue.unbounded<K>(), TxQueue.shutdown);
+ const stateRef = yield* TxRef.make<KeyedDrainableWorkerState<K, A>>({
+ lanes: new Map(),
+ outstanding: 0,
+ });
+
+ const take = TxQueue.take(readyKeys).pipe(
+ Effect.flatMap((key) =>
+ TxRef.modify(stateRef, (state) => {
+ const lane = state.lanes.get(key);
+ if (lane === undefined || lane.length === 0) {
+ return [undefined, state] as const;
+ }
+ const item = lane[0] as A;
+ const lanes = new Map(state.lanes);
+ lanes.set(key, lane.slice(1));
+ return [
+ { key, item },
+ { ...state, lanes },
+ ] as const;
+ }),
+ ),
+ Effect.tx,
+ );
+
+ const complete = (key: K) =>
+ TxRef.modify(stateRef, (state) => {
+ const lane = state.lanes.get(key);
+ const lanes = new Map(state.lanes);
+ if (lane === undefined || lane.length === 0) {
+ lanes.delete(key);
+ return [false, { lanes, outstanding: state.outstanding - 1 }] as const;
+ }
+ return [true, { lanes, outstanding: state.outstanding - 1 }] as const;
+ }).pipe(
+ Effect.flatMap((requeue) => (requeue ? TxQueue.offer(readyKeys, key) : Effect.void)),
+ Effect.tx,
+ Effect.asVoid,
+ );
+
+ const runWorker = take.pipe(
+ Effect.flatMap((work) =>
+ work === undefined
+ ? Effect.void
+ : options.process(work.item).pipe(
+ Effect.catchCause((cause) =>
+ Cause.hasInterruptsOnly(cause) ? Effect.interrupt : Effect.void,
+ ),
+ Effect.ensuring(complete(work.key)),
+ ),
+ ),
+ Effect.forever,
+ );
+
+ yield* Effect.forEach(Array.from({ length: concurrency }), () => Effect.forkScoped(runWorker), {
+ discard: true,
+ });
+
+ const enqueue: KeyedDrainableWorker<K, A>["enqueue"] = (key, item) =>
+ TxRef.modify(stateRef, (state) => {
+ const lane = state.lanes.get(key);
+ const lanes = new Map(state.lanes);
+ lanes.set(key, [...(lane ?? []), item]);
+ return [lane === undefined, { lanes, outstanding: state.outstanding + 1 }] as const;
+ }).pipe(
+ Effect.flatMap((offer) => (offer ? TxQueue.offer(readyKeys, key) : Effect.void)),
+ Effect.tx,
+ Effect.asVoid,
+ );
+
+ const drain = TxRef.get(stateRef).pipe(
+ Effect.tap((state) => (state.outstanding > 0 ? Effect.txRetry : Effect.void)),
+ Effect.tx,
+ Effect.asVoid,
+ );
+
+ return { enqueue, drain } satisfies KeyedDrainableWorker<K, A>;
+ });
type ThreadTitleMessage = {
readonly role: "user" | "assistant" | "system";
@@ -2432,7 +2531,22 @@ const make = Effect.gen(function* () {
}),
);
- const worker = yield* makeDrainableWorker(processDomainEventSafely);
+ const providerCommandLaneKey = (event: ProviderIntentEvent): string =>
+ event.type === "delegation.updated"
+ ? event.payload.delegation.phase._tag === "Queued"
+ ? event.payload.delegation.parentThreadId
+ : (event.payload.delegation.phase.childThreadId ?? event.payload.delegation.parentThreadId)
+ : event.type === "delegation.retry-requested"
+ ? event.payload.parentThreadId
+ : event.payload.threadId;
+
+ const worker = yield* makeKeyedDrainableWorker({
+ concurrency: PROVIDER_COMMAND_CONCURRENCY,
+ process: processDomainEventSafely,
+ });
+
+ const enqueueProviderCommand = (event: ProviderIntentEvent) =>
+ worker.enqueue(providerCommandLaneKey(event), event);
const findPersistedTurnStart = Effect.fn("findPersistedTurnStart")(function* (input: {
readonly threadId: ThreadId;
@@ -2644,7 +2758,7 @@ const make = Effect.gen(function* () {
throughSequence,
});
if (event) {
- yield* worker.enqueue(event);
+ yield* enqueueProviderCommand(event);
} else {
yield* Effect.logWarning("provider command reactor could not recover pending turn event", {
threadId: pending.threadId,
@@ -2670,7 +2784,7 @@ const make = Effect.gen(function* () {
});
if (event) {
pendingThreadIds.add(String(thread.id));
- yield* worker.enqueue(event);
+ yield* enqueueProviderCommand(event);
} else {
yield* Effect.logWarning(
"provider command reactor could not recover pending resume event",
@@ -2826,7 +2940,7 @@ const make = Effect.gen(function* () {
event.type === "delegation.updated" ||
event.type === "delegation.retry-requested"
) {
- return yield* worker.enqueue(event);
+ yield* enqueueProviderCommand(event);
}
});
diff --git a/apps/server/src/provider/Layers/AgentController.test.ts b/apps/server/src/provider/Layers/AgentController.test.ts
index 046963033..b9f1e8582 100644
--- a/apps/server/src/provider/Layers/AgentController.test.ts
+++ b/apps/server/src/provider/Layers/AgentController.test.ts
@@ -684,6 +684,7 @@ function makeLayer(
| "botMemoryStore"
| "webFetch"
| "generateImage"
+ | "readAttachment"
>,
delegationRuntime?: AgentControllerLiveOptions["delegationRuntime"],
settingsOverrides?: Parameters<typeof serverSettingsLayerTest>[0],
@@ -740,6 +741,7 @@ function provideController<A, E>(
| "botMemoryStore"
| "webFetch"
| "generateImage"
+ | "readAttachment"
>,
settingsOverrides?: Parameters<typeof serverSettingsLayerTest>[0],
settingsLayer?: Layer.Layer<ServerSettingsService>,
@@ -4469,6 +4471,80 @@ describe("AgentControllerLive", () => {
);
});
+ for (const action of ["replace", "interrupt", "stop"] as const) {
+ it.effect(`does not enqueue an attachment turn after session ${action}`, () => {
+ const bridge = makeBridge();
+ const mastra = makeMastraHarness();
+
+ return Effect.gen(function* () {
+ let markReadStarted!: () => void;
+ const readStarted = new Promise<void>((resolve) => {
+ markReadStarted = resolve;
+ });
+ let releaseRead!: (bytes: Uint8Array) => void;
+ const blockedRead = new Promise<Uint8Array>((resolve) => {
+ releaseRead = resolve;
+ });
+ const layer = makeLayer(bridge.service, mastra.factory, undefined, undefined, undefined, {
+ readAttachment: () => {
+ markReadStarted();
+ return blockedRead;
+ },
+ });
+ const program = Effect.gen(function* () {
+ const controller = yield* AgentController;
+ yield* resolveCodex(controller);
+ yield* controller.startSession(codexThreadId, {
+ threadId: codexThreadId,
+ provider: ProviderDriverKind.make("codex"),
+ providerInstanceId: codexInstanceId,
+ cwd: process.cwd(),
+ modelSelection: codexSelection,
+ runtimeMode: "full-access",
+ });
+ const sending = yield* controller
+ .sendTurn({
+ threadId: codexThreadId,
+ input: "Inspect this image.",
+ attachments: [
+ {
+ type: "image",
+ id: "image-1",
+ name: "screenshot.png",
+ mimeType: "image/png",
+ sizeBytes: 4,
+ },
+ ],
+ })
+ .pipe(Effect.forkChild({ startImmediately: true }));
+ yield* Effect.promise(() => readStarted);
+ expect(yield* controller.listSessions()).toHaveLength(1);
+
+ if (action === "replace") {
+ yield* controller.startSession(codexThreadId, {
+ threadId: codexThreadId,
+ provider: ProviderDriverKind.make("codex"),
+ providerInstanceId: codexInstanceId,
+ cwd: NodeOS.tmpdir(),
+ modelSelection: codexSelection,
+ runtimeMode: "full-access",
+ });
+ } else if (action === "interrupt") {
+ yield* controller.interruptTurn({ threadId: codexThreadId });
+ } else {
+ yield* controller.stopSession({ threadId: codexThreadId });
+ }
+ releaseRead(new Uint8Array([0, 1, 2, 3]));
+
+ const exit = yield* Fiber.await(sending);
+ assert.isTrue(Exit.isFailure(exit));
+ expect(mastra.sendMessage).not.toHaveBeenCalled();
+ });
+ yield* program.pipe(Effect.provide(layer));
+ }).pipe(Effect.orDie);
+ });
+ }
+
it.effect("dispatches the drop activity without an active session", () => {
const bridge = makeBridge();
const mastra = makeMastraHarness();
@@ -6501,6 +6577,57 @@ describe("AgentControllerLive", () => {
);
});
+ it.effect(
+ "preserves attachment order and typed-array byte ranges during asynchronous reads",
+ () => {
+ const bridge = makeBridge();
+ const mastra = makeMastraHarness();
+ const readAttachment = vi.fn(async (path: string) =>
+ path.endsWith("image-1.png")
+ ? new Uint8Array([99, 1, 2, 3, 99]).subarray(1, 4)
+ : new Uint8Array([4, 5]),
+ );
+ const layer = makeLayer(bridge.service, mastra.factory, undefined, undefined, undefined, {
+ readAttachment,
+ });
+ return Effect.gen(function* () {
+ const controller = yield* AgentController;
+ yield* resolveCodex(controller);
+ yield* controller.startSession(codexThreadId, {
+ threadId: codexThreadId,
+ provider: ProviderDriverKind.make("codex"),
+ providerInstanceId: codexInstanceId,
+ cwd: process.cwd(),
+ modelSelection: codexSelection,
+ runtimeMode: "full-access",
+ });
+ yield* controller.sendTurn({
+ threadId: codexThreadId,
+ input: "Inspect both images.",
+ attachments: ["image-1", "image-2"].map((id) => ({
+ type: "image" as const,
+ id,
+ name: `${id}.png`,
+ mimeType: "image/png",
+ sizeBytes: 3,
+ })),
+ });
+ expect(readAttachment.mock.calls.map(([path]) => NodePath.basename(path))).toEqual([
+ "image-1.png",
+ "image-2.png",
+ ]);
+ expect(mastra.sendMessage).toHaveBeenCalledWith(
+ expect.objectContaining({
+ files: [
+ { data: "AQID", mediaType: "image/png", filename: "image-1.png" },
+ { data: "BAU=", mediaType: "image/png", filename: "image-2.png" },
+ ],
+ }),
+ );
+ }).pipe(Effect.provide(layer), Effect.orDie);
+ },
+ );
+
it.effect("reads persisted image attachments for Mastra turns", () => {
const bridge = makeBridge();
const mastra = makeMastraHarness();
diff --git a/apps/server/src/provider/Layers/AgentController.ts b/apps/server/src/provider/Layers/AgentController.ts
index 26f1206d0..f9615cc83 100644
--- a/apps/server/src/provider/Layers/AgentController.ts
+++ b/apps/server/src/provider/Layers/AgentController.ts
@@ -293,6 +293,7 @@ interface ActiveSession {
runtimeMode: RuntimeMode;
model: string;
status: ProviderSession["status"];
+ turnAdmissionGeneration: number;
activeTurn: ActiveTurn | null;
admittingTurn: PendingTurn | null;
readonly pendingTurns: PendingTurn[];
@@ -372,6 +373,7 @@ export interface AgentControllerLiveOptions {
"send" | "sendToUser" | "parentFinished" | "accessForThread"
> &
Partial<Pick<AkeruDelegationRuntime, "create" | "check" | "stop" | "dispatchDelegation">>;
+ readonly readAttachment?: (path: string) => Promise<Uint8Array>;
/** Overrides the WebFetch resolver and address policy in tests. */
readonly webFetch?: AkeruWebFetchOptions;
/**
@@ -3571,6 +3573,7 @@ const make = (options?: AgentControllerLiveOptions) =>
runtimeMode: access.runtimeMode,
model: resolved.modelSelection.model,
status: "ready" as const,
+ turnAdmissionGeneration: 0,
activeTurn: null,
admittingTurn: null,
pendingTurns: [],
@@ -3760,6 +3763,7 @@ const make = (options?: AgentControllerLiveOptions) =>
),
);
}
+ const turnAdmissionGeneration = active.turnAdmissionGeneration;
if (input.timezone !== undefined) {
active.configuredToolSession = {
...active.configuredToolSession,
@@ -3770,36 +3774,55 @@ const make = (options?: AgentControllerLiveOptions) =>
toolRuntime.registerSession(key, active.toolSession);
}
}
- const attachmentFiles = yield* Effect.forEach(input.attachments ?? [], (attachment) => {
- const path = resolveAttachmentPath({
- attachmentsDir: config.attachmentsDir,
- attachment,
- });
- if (path === null) {
- return Effect.fail(
- new AgentControllerRuntimeError({
- operation: "sendTurn.attachments",
- detail: `Attachment '${attachment.id}' has an invalid path.`,
- }),
- );
- }
- return Effect.try({
- try: () => ({
- file: {
- data: NodeFS.readFileSync(path).toString("base64"),
- mediaType: attachment.mimeType,
- filename: attachment.name,
+ const attachmentFiles = yield* Effect.forEach(
+ input.attachments ?? [],
+ (attachment) => {
+ const path = resolveAttachmentPath({
+ attachmentsDir: config.attachmentsDir,
+ attachment,
+ });
+ if (path === null) {
+ return Effect.fail(
+ new AgentControllerRuntimeError({
+ operation: "sendTurn.attachments",
+ detail: `Attachment '${attachment.id}' has an invalid path.`,
+ }),
+ );
+ }
+ return Effect.tryPromise({
+ try: async () => {
+ const bytes = await (options?.readAttachment ?? NodeFS.promises.readFile)(path);
+ return {
+ file: {
+ data: Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString(
+ "base64",
+ ),
+ mediaType: attachment.mimeType,
+ filename: attachment.name,
+ },
+ pathLine: `[Attached ${attachment.type} "${attachment.name}" is saved at: ${path}]`,
+ };
},
- pathLine: `[Attached ${attachment.type} "${attachment.name}" is saved at: ${path}]`,
- }),
- catch: (cause) =>
- new AgentControllerRuntimeError({
- operation: "sendTurn.attachments",
- detail: `Could not read attachment '${attachment.id}'.`,
- cause,
- }),
+ catch: (cause) =>
+ new AgentControllerRuntimeError({
+ operation: "sendTurn.attachments",
+ detail: `Could not read attachment '${attachment.id}'.`,
+ cause,
+ }),
+ });
+ },
+ { concurrency: 1 },
+ );
+ if (
+ sessions.get(key) !== active ||
+ active.status === "closed" ||
+ active.turnAdmissionGeneration !== turnAdmissionGeneration
+ ) {
+ return yield* new AgentControllerRuntimeError({
+ operation: "sendTurn",
+ detail: `Mastra session for thread '${input.threadId}' is not running.`,
});
- });
+ }
const content = [input.input, ...attachmentFiles.map(({ pathLine }) => pathLine)]
.filter((part): part is string => typeof part === "string" && part.length > 0)
.join("\n\n");
@@ -3863,6 +3886,7 @@ const make = (options?: AgentControllerLiveOptions) =>
),
);
}
+ active.turnAdmissionGeneration += 1;
active.pendingTurns.length = 0;
active.admittingTurn = null;
active.session.abort();
@@ -4241,6 +4265,7 @@ const make = (options?: AgentControllerLiveOptions) =>
}
return yield* legacyProviderBridge.stopSession(input);
}
+ active.turnAdmissionGeneration += 1;
active.pendingTurns.length = 0;
active.admittingTurn = null;
active.session.abort();
@@ -4413,6 +4438,7 @@ const make = (options?: AgentControllerLiveOptions) =>
yield* Effect.addFinalizer(() =>
Effect.gen(function* () {
for (const [threadId, active] of sessions) {
+ active.turnAdmissionGeneration += 1;
active.pendingTurns.length = 0;
active.admittingTurn = null;
active.session.abort();
diff --git a/apps/server/src/workspace/WorkspaceEntries.test.ts b/apps/server/src/workspace/WorkspaceEntries.test.ts
index c88153b02..44ea3982d 100644
--- a/apps/server/src/workspace/WorkspaceEntries.test.ts
+++ b/apps/server/src/workspace/WorkspaceEntries.test.ts
@@ -1,3 +1,4 @@
+import * as Deferred from "effect/Deferred";
// @effect-diagnostics nodeBuiltinImport:off
import * as NodeServices from "@effect/platform-node/NodeServices";
import { FileFinder } from "@ff-labs/fff-node";
@@ -81,6 +82,138 @@ const searchWorkspaceEntries = (input: {
return yield* workspaceEntries.search(input);
});
+describe("workspace refresh worker", () => {
+ it.effect("allows publication and other workspaces while a scan is blocked", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const startedA = yield* Deferred.make<void>();
+ const startedB = yield* Deferred.make<void>();
+ const releaseA = yield* Deferred.make<void>();
+ const releaseB = yield* Deferred.make<void>();
+ const worker = yield* WorkspaceEntries.makeWorkspaceRefreshWorker((cwd) =>
+ cwd === "/a"
+ ? Deferred.succeed(startedA, undefined).pipe(Effect.andThen(Deferred.await(releaseA)))
+ : Deferred.succeed(startedB, undefined).pipe(Effect.andThen(Deferred.await(releaseB))),
+ );
+
+ yield* worker.request("/a");
+ yield* Deferred.await(startedA);
+ yield* worker.request("/b");
+ yield* Deferred.await(startedB);
+
+ const bFresh = yield* Deferred.make<void>();
+ yield* worker
+ .awaitCurrent("/b")
+ .pipe(Effect.andThen(Deferred.succeed(bFresh, undefined)), Effect.forkScoped);
+ yield* Deferred.succeed(releaseB, undefined);
+ yield* Deferred.await(bFresh);
+ expect(yield* Deferred.isDone(releaseA)).toBe(false);
+
+ const drained = yield* Deferred.make<void>();
+ yield* worker.drain.pipe(
+ Effect.andThen(Deferred.succeed(drained, undefined)),
+ Effect.forkScoped,
+ );
+ expect(yield* Deferred.isDone(drained)).toBe(false);
+ yield* Deferred.succeed(releaseA, undefined);
+ yield* Deferred.await(drained);
+ }),
+ ),
+ );
+
+ it.effect("coalesces requests during a scan into one follow-up generation", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const firstStarted = yield* Deferred.make<void>();
+ const secondStarted = yield* Deferred.make<void>();
+ const releaseFirst = yield* Deferred.make<void>();
+ const releaseSecond = yield* Deferred.make<void>();
+ let scans = 0;
+ const worker = yield* WorkspaceEntries.makeWorkspaceRefreshWorker(() => {
+ scans += 1;
+ return scans === 1
+ ? Deferred.succeed(firstStarted, undefined).pipe(
+ Effect.andThen(Deferred.await(releaseFirst)),
+ )
+ : Deferred.succeed(secondStarted, undefined).pipe(
+ Effect.andThen(Deferred.await(releaseSecond)),
+ );
+ });
+
+ yield* worker.request("/workspace");
+ yield* Deferred.await(firstStarted);
+ yield* worker.request("/workspace");
+ yield* worker.request("/workspace");
+ yield* Deferred.succeed(releaseFirst, undefined);
+ yield* Deferred.await(secondStarted);
+ expect(scans).toBe(2);
+
+ const fresh = yield* Deferred.make<void>();
+ yield* worker
+ .awaitCurrent("/workspace")
+ .pipe(Effect.andThen(Deferred.succeed(fresh, undefined)), Effect.forkScoped);
+ expect(yield* Deferred.isDone(fresh)).toBe(false);
+ yield* Deferred.succeed(releaseSecond, undefined);
+ yield* Deferred.await(fresh);
+ yield* worker.drain;
+ expect(scans).toBe(2);
+ }),
+ ),
+ );
+
+ it.effect("bounds concurrent scans and can refresh an idle workspace again", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const twoStarted = yield* Deferred.make<void>();
+ const release = yield* Deferred.make<void>();
+ let active = 0;
+ let maximum = 0;
+ let scans = 0;
+ const worker = yield* WorkspaceEntries.makeWorkspaceRefreshWorker(() =>
+ Effect.gen(function* () {
+ scans += 1;
+ active += 1;
+ maximum = Math.max(maximum, active);
+ if (active === 2) yield* Deferred.succeed(twoStarted, undefined);
+ yield* Deferred.await(release);
+ active -= 1;
+ }),
+ );
+ for (const cwd of ["/a", "/b", "/c", "/d"]) yield* worker.request(cwd);
+ yield* Deferred.await(twoStarted);
+ yield* Deferred.succeed(release, undefined);
+ yield* worker.drain;
+ expect(maximum).toBe(2);
+ expect(scans).toBe(4);
+ yield* worker.request("/a");
+ yield* worker.awaitCurrent("/a");
+ yield* worker.drain;
+ expect(scans).toBe(5);
+ }),
+ ),
+ );
+
+ it.effect("completes failed generations and remains drainable", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ let scans = 0;
+ const worker = yield* WorkspaceEntries.makeWorkspaceRefreshWorker(() =>
+ Effect.sync(() => {
+ scans += 1;
+ if (scans === 1) throw new Error("scan failed");
+ }),
+ );
+
+ yield* worker.request("/workspace");
+ yield* worker.drain;
+ yield* worker.request("/workspace");
+ yield* worker.drain;
+ expect(scans).toBe(2);
+ }),
+ ),
+ );
+});
+
it.layer(TestLayer, { excludeTestServices: true })("WorkspaceEntries", (it) => {
afterEach(() => {
vi.restoreAllMocks();
diff --git a/apps/server/src/workspace/WorkspaceEntries.ts b/apps/server/src/workspace/WorkspaceEntries.ts
index 6ccbde6a6..1c33cf3b8 100644
--- a/apps/server/src/workspace/WorkspaceEntries.ts
+++ b/apps/server/src/workspace/WorkspaceEntries.ts
@@ -1,3 +1,7 @@
+import * as Cause from "effect/Cause";
+import * as Deferred from "effect/Deferred";
+import * as Scope from "effect/Scope";
+import * as Semaphore from "effect/Semaphore";
import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
@@ -35,10 +39,106 @@ export class WorkspaceEntries extends Context.Service<
readonly search: (
input: ProjectSearchEntriesInput,
) => Effect.Effect<ProjectSearchEntriesResult, WorkspaceEntriesError>;
+ readonly drain?: Effect.Effect<void>;
readonly refresh: (cwd: string) => Effect.Effect<void>;
}
>()("akeru-bot/workspace/WorkspaceEntries") {}
+type WorkspaceRefreshState = {
+ requestedGeneration: number;
+ completedGeneration: number;
+ running: boolean;
+ readonly waiters: Map<number, Deferred.Deferred<void>>;
+};
+
+export const makeWorkspaceRefreshWorker = (scan: (normalizedCwd: string) => Effect.Effect<void>) =>
+ Effect.gen(function* () {
+ const states = new Map<string, WorkspaceRefreshState>();
+ const scope = yield* Scope.make();
+ yield* Effect.addFinalizer((exit) => Scope.close(scope, exit));
+
+ const scanPermits = yield* Semaphore.make(2);
+ const run = Effect.fn("WorkspaceEntries.refreshWorker.run")(function* (normalizedCwd: string) {
+ const state = states.get(normalizedCwd);
+ if (!state) return;
+ while (true) {
+ const generation = yield* scanPermits.withPermits(1)(
+ Effect.gen(function* () {
+ const generation = state.requestedGeneration;
+ yield* scan(normalizedCwd).pipe(
+ Effect.catchCause((cause) =>
+ Cause.hasInterruptsOnly(cause)
+ ? Effect.interrupt
+ : Effect.logWarning("Workspace refresh generation failed", {
+ normalizedCwd,
+ cause,
+ }),
+ ),
+ );
+ return generation;
+ }),
+ );
+ state.completedGeneration = generation;
+ for (const [waiterGeneration, waiter] of state.waiters) {
+ if (waiterGeneration <= generation) {
+ state.waiters.delete(waiterGeneration);
+ yield* Deferred.succeed(waiter, undefined);
+ }
+ }
+ if (state.requestedGeneration === generation) {
+ states.delete(normalizedCwd);
+ return;
+ }
+ }
+ });
+
+ const request = Effect.fn("WorkspaceEntries.refreshWorker.request")(function* (
+ normalizedCwd: string,
+ ) {
+ const waiter = yield* Deferred.make<void>();
+ let state = states.get(normalizedCwd);
+ if (!state) {
+ state = {
+ requestedGeneration: 0,
+ completedGeneration: 0,
+ running: false,
+ waiters: new Map(),
+ };
+ states.set(normalizedCwd, state);
+ }
+ const generation = ++state.requestedGeneration;
+ state.waiters.set(generation, waiter);
+ if (!state.running) {
+ state.running = true;
+ yield* Effect.forkIn(run(normalizedCwd), scope);
+ }
+ });
+
+ const awaitCurrent = Effect.fn("WorkspaceEntries.refreshWorker.awaitCurrent")(function* (
+ normalizedCwd: string,
+ ) {
+ while (true) {
+ const state = states.get(normalizedCwd);
+ if (!state || state.completedGeneration >= state.requestedGeneration) return;
+ const waiter = state.waiters.get(state.requestedGeneration);
+ if (waiter) yield* Deferred.await(waiter);
+ }
+ });
+
+ const drain: Effect.Effect<void> = Effect.suspend(() => {
+ const pending = Array.from(states.values()).flatMap((state) =>
+ Array.from(state.waiters.values()),
+ );
+ return pending.length === 0
+ ? Effect.void
+ : Effect.all(pending.map(Deferred.await), { concurrency: "unbounded" }).pipe(
+ Effect.andThen(drain),
+ );
+ });
+
+ return { request, awaitCurrent, drain } as const;
+ });
+
export const make = Effect.gen(function* () {
const workspacePaths = yield* WorkspacePaths.WorkspacePaths;
const workspaceSearchIndexes = yield* WorkspaceSearchIndex.WorkspaceSearchIndexMap;
@@ -49,41 +149,50 @@ export const make = Effect.gen(function* () {
return yield* workspacePaths.normalizeWorkspaceRoot(cwd);
});
+ const scan = Effect.fn("WorkspaceEntries.scan")(function* (normalizedCwd: string) {
+ if (!(yield* RcMap.has(workspaceSearchIndexes.rcMap, normalizedCwd))) {
+ return;
+ }
+ const recoverRefreshFailure = (
+ cause:
+ | WorkspaceSearchIndex.WorkspaceSearchIndexCreateFailed
+ | WorkspaceSearchIndex.WorkspaceSearchIndexScanTimedOut
+ | WorkspaceSearchIndex.WorkspaceSearchIndexRefreshFailed,
+ ) =>
+ Effect.gen(function* () {
+ yield* Effect.logWarning("Failed to refresh workspace search index", {
+ cwd: normalizedCwd,
+ cause,
+ });
+ yield* workspaceSearchIndexes.invalidate(normalizedCwd);
+ });
+ yield* Effect.gen(function* () {
+ const searchIndex = yield* WorkspaceSearchIndex.WorkspaceSearchIndex;
+ yield* searchIndex.refresh();
+ }).pipe(
+ Effect.provide(workspaceSearchIndexes.get(normalizedCwd)),
+ Effect.catchTags({
+ WorkspaceSearchIndexCreateFailed: recoverRefreshFailure,
+ WorkspaceSearchIndexScanTimedOut: recoverRefreshFailure,
+ WorkspaceSearchIndexRefreshFailed: recoverRefreshFailure,
+ }),
+ );
+ });
+
+ const refreshWorker = yield* makeWorkspaceRefreshWorker(scan);
const refresh: WorkspaceEntries["Service"]["refresh"] = Effect.fn("WorkspaceEntries.refresh")(
function* (cwd) {
const normalizedCwd = yield* normalizeWorkspaceRoot(cwd).pipe(
Effect.orElseSucceed(() => cwd),
);
- if (!(yield* RcMap.has(workspaceSearchIndexes.rcMap, normalizedCwd))) {
- return;
- }
- const recoverRefreshFailure = (
- cause:
- | WorkspaceSearchIndex.WorkspaceSearchIndexCreateFailed
- | WorkspaceSearchIndex.WorkspaceSearchIndexScanTimedOut
- | WorkspaceSearchIndex.WorkspaceSearchIndexRefreshFailed,
- ) =>
- Effect.gen(function* () {
- yield* Effect.logWarning("Failed to refresh workspace search index", { cwd, cause });
- yield* workspaceSearchIndexes.invalidate(normalizedCwd);
- });
- yield* Effect.gen(function* () {
- const searchIndex = yield* WorkspaceSearchIndex.WorkspaceSearchIndex;
- yield* searchIndex.refresh();
- }).pipe(
- Effect.provide(workspaceSearchIndexes.get(normalizedCwd)),
- Effect.catchTags({
- WorkspaceSearchIndexCreateFailed: recoverRefreshFailure,
- WorkspaceSearchIndexScanTimedOut: recoverRefreshFailure,
- WorkspaceSearchIndexRefreshFailed: recoverRefreshFailure,
- }),
- );
+ yield* refreshWorker.request(normalizedCwd);
},
);
const search: WorkspaceEntries["Service"]["search"] = Effect.fn("WorkspaceEntries.search")(
function* (input) {
const normalizedCwd = yield* normalizeWorkspaceRoot(input.cwd);
+ yield* refreshWorker.awaitCurrent(normalizedCwd);
const normalizedQuery = normalizeSearchQuery(input.query, {
trimLeadingPattern: /^[@./]+/,
});
@@ -97,6 +206,7 @@ export const make = Effect.gen(function* () {
const list: WorkspaceEntries["Service"]["list"] = Effect.fn("WorkspaceEntries.list")(
function* (input) {
const normalizedCwd = yield* normalizeWorkspaceRoot(input.cwd);
+ yield* refreshWorker.awaitCurrent(normalizedCwd);
return yield* Effect.gen(function* () {
const searchIndex = yield* WorkspaceSearchIndex.WorkspaceSearchIndex;
return yield* searchIndex.list();
@@ -104,7 +214,7 @@ export const make = Effect.gen(function* () {
},
);
- return WorkspaceEntries.of({ list, refresh, search });
+ return WorkspaceEntries.of({ list, refresh, search, drain: refreshWorker.drain });
});
export const layer = Layer.effect(WorkspaceEntries, make).pipe(
diff --git a/apps/web/src/components/roster/botConversationMessageProjection.test.ts b/apps/web/src/components/roster/botConversationMessageProjection.test.ts
new file mode 100644
index 000000000..dcdfc5570
--- /dev/null
+++ b/apps/web/src/components/roster/botConversationMessageProjection.test.ts
@@ -0,0 +1,123 @@
+import { MessageId, TurnId, type OrchestrationMessage } from "@akeru/contracts";
+import { Atom, AtomRegistry } from "effect/unstable/reactivity";
+import { describe, expect, it } from "vite-plus/test";
+
+import {
+ createBotConversationMessageProjectionAtom,
+ type BotConversationMessageProjection,
+} from "./botConversationMessageProjection";
+
+const message = (
+ id: string,
+ role: "user" | "assistant" | "system",
+ streaming: boolean,
+ turnId: string | null = null,
+): OrchestrationMessage =>
+ ({
+ id: MessageId.make(id),
+ role,
+ text: id,
+ turnId: turnId === null ? null : TurnId.make(turnId),
+ streaming,
+ createdAt: "2026-09-18T00:00:00.000Z",
+ updatedAt: "2026-09-18T00:00:00.000Z",
+ }) as const;
+
+describe("bot conversation message projection atom", () => {
+ it("retains raw-history control metadata for hidden routine requests", () => {
+ const source = Atom.make<ReadonlyArray<OrchestrationMessage>>([]);
+ const projection = createBotConversationMessageProjectionAtom(source);
+ const registry = AtomRegistry.make();
+ const observed: BotConversationMessageProjection[] = [];
+ const unsubscribe = registry.subscribe(projection, (value) => observed.push(value), {
+ immediate: true,
+ });
+ const first = message("routine:first", "user", false);
+ const second = {
+ ...message("routine:second", "user", false),
+ createdAt: "2026-09-18T01:00:00.000Z",
+ };
+
+ try {
+ expect(observed[0]).toMatchObject({ hasMessages: false, lastUserMessageAt: null });
+ registry.set(source, [first]);
+ expect(observed[1]).toMatchObject({
+ messages: [],
+ hasMessages: true,
+ lastUserMessageAt: first.createdAt,
+ });
+ registry.set(source, [first, second]);
+ expect(observed).toHaveLength(3);
+ expect(observed[2]!.messages).toBe(observed[1]!.messages);
+ expect(observed[2]!.lastUserMessageAt).toBe(second.createdAt);
+ registry.set(source, []);
+ expect(observed[3]).toMatchObject({ hasMessages: false, lastUserMessageAt: null });
+ } finally {
+ unsubscribe();
+ registry.dispose();
+ }
+ });
+
+ it("does not publish hidden streaming deltas but publishes completion and visible edits", () => {
+ const user = message("user", "user", false);
+ const streaming = message("reply", "assistant", true, "turn-1");
+ const source = Atom.make<ReadonlyArray<OrchestrationMessage>>([user, streaming]);
+ const projection = createBotConversationMessageProjectionAtom(source);
+ const registry = AtomRegistry.make();
+ const observed: BotConversationMessageProjection[] = [];
+ const unsubscribe = registry.subscribe(projection, (value) => observed.push(value), {
+ immediate: true,
+ });
+
+ try {
+ const initial = observed[0]!;
+ expect(initial.messages).toEqual([user]);
+ expect(initial.lastMessageRole).toBe("assistant");
+
+ registry.set(source, [user, { ...streaming, text: "reply delta" }]);
+ expect(observed).toHaveLength(1);
+
+ const editedUser = { ...user, text: "edited user message" };
+ registry.set(source, [editedUser, { ...streaming, text: "another hidden delta" }]);
+ expect(observed).toHaveLength(2);
+ expect(observed[1]!.messages[0]).toBe(editedUser);
+
+ registry.set(source, [editedUser, { ...streaming, text: "one more hidden delta" }]);
+ expect(observed).toHaveLength(2);
+
+ const completed = { ...streaming, streaming: false, text: "final answer" };
+ registry.set(source, [editedUser, completed]);
+ expect(observed).toHaveLength(3);
+ expect(observed[2]!.messages).toEqual([editedUser, completed]);
+
+ const edited = { ...completed, reactions: [] };
+ registry.set(source, [editedUser, edited]);
+ expect(observed).toHaveLength(4);
+ expect(observed[3]!.messages[1]).toBe(edited);
+ } finally {
+ unsubscribe();
+ registry.dispose();
+ }
+ });
+
+ it("publishes last-message role changes needed by resume controls", () => {
+ const user = message("user", "user", false);
+ const source = Atom.make<ReadonlyArray<OrchestrationMessage>>([user]);
+ const projection = createBotConversationMessageProjectionAtom(source);
+ const registry = AtomRegistry.make();
+ const observed: string[] = [];
+ const unsubscribe = registry.subscribe(
+ projection,
+ (value) => observed.push(value.lastMessageRole ?? "none"),
+ { immediate: true },
+ );
+
+ try {
+ registry.set(source, [user, message("status", "system", false)]);
+ expect(observed).toEqual(["user", "system"]);
+ } finally {
+ unsubscribe();
+ registry.dispose();
+ }
+ });
+});
diff --git a/apps/web/src/components/roster/botConversationMessageProjection.ts b/apps/web/src/components/roster/botConversationMessageProjection.ts
new file mode 100644
index 000000000..58166d054
--- /dev/null
+++ b/apps/web/src/components/roster/botConversationMessageProjection.ts
@@ -0,0 +1,81 @@
+import { useAtomValue } from "@effect/atom-react";
+import { parseThreadKey, threadKey } from "@akeru/client-runtime/state/entities";
+import type { OrchestrationMessage, ScopedThreadRef } from "@akeru/contracts";
+import { Atom } from "effect/unstable/reactivity";
+
+import { environmentThreadDetails } from "../../state/threads";
+import { visibleBotChatMessages } from "./botConversationPresentation";
+
+const THREAD_PROJECTION_IDLE_TTL_MS = 5 * 60_000;
+const EMPTY_MESSAGES: ReadonlyArray<OrchestrationMessage> = Object.freeze([]);
+
+export interface BotConversationMessageProjection {
+ readonly messages: ReadonlyArray<OrchestrationMessage>;
+ readonly lastMessageRole: OrchestrationMessage["role"] | null;
+ readonly hasMessages: boolean;
+ readonly lastUserMessageAt: string | null;
+}
+
+const EMPTY_PROJECTION: BotConversationMessageProjection = Object.freeze({
+ messages: EMPTY_MESSAGES,
+ lastMessageRole: null,
+ hasMessages: false,
+ lastUserMessageAt: null,
+});
+
+const EMPTY_PROJECTION_ATOM = Atom.make(EMPTY_PROJECTION).pipe(
+ Atom.withLabel("web-bot-conversation-messages:empty"),
+);
+
+function sameMessageReferences(
+ left: ReadonlyArray<OrchestrationMessage>,
+ right: ReadonlyArray<OrchestrationMessage>,
+): boolean {
+ return left.length === right.length && left.every((message, index) => message === right[index]);
+}
+
+export function createBotConversationMessageProjectionAtom(
+ source: Atom.Atom<ReadonlyArray<OrchestrationMessage>>,
+ label = "web-bot-conversation-messages:test",
+): Atom.Atom<BotConversationMessageProjection> {
+ let previous = EMPTY_PROJECTION;
+
+ return Atom.make((get) => {
+ const rawMessages = get(source);
+ const nextMessages = visibleBotChatMessages(rawMessages);
+ const messages = sameMessageReferences(previous.messages, nextMessages)
+ ? previous.messages
+ : nextMessages;
+ const lastMessageRole = rawMessages.at(-1)?.role ?? null;
+ const hasMessages = rawMessages.length > 0;
+ const lastUserMessageAt =
+ rawMessages.findLast((message) => message.role === "user")?.createdAt ?? null;
+
+ if (
+ messages === previous.messages &&
+ lastMessageRole === previous.lastMessageRole &&
+ hasMessages === previous.hasMessages &&
+ lastUserMessageAt === previous.lastUserMessageAt
+ ) {
+ return previous;
+ }
+ previous = { messages, lastMessageRole, hasMessages, lastUserMessageAt };
+ return previous;
+ }).pipe(Atom.setIdleTTL(THREAD_PROJECTION_IDLE_TTL_MS), Atom.withLabel(label));
+}
+
+const botConversationMessageProjectionAtom = Atom.family((key: string) => {
+ const ref = parseThreadKey(key);
+ return createBotConversationMessageProjectionAtom(
+ environmentThreadDetails.messagesAtom(ref),
+ `web-bot-conversation-messages:${key}`,
+ );
+});
+
+export function useBotConversationMessageProjection(
+ ref: ScopedThreadRef | null,
+): BotConversationMessageProjection {
+ return useAtomValue(
+ ref === null ? EMPTY_PROJECTION_ATOM : botConversationMessageProjectionAtom(threadKey(ref)),
+ );
+}
diff --git a/apps/web/src/components/roster/useBotThreadRuntime.newChat.test.ts b/apps/web/src/components/roster/useBotThreadRuntime.newChat.test.ts
index 31691f169..74df29856 100644
--- a/apps/web/src/components/roster/useBotThreadRuntime.newChat.test.ts
+++ b/apps/web/src/components/roster/useBotThreadRuntime.newChat.test.ts
@@ -25,6 +25,12 @@ const mocks = vi.hoisted(() => {
};
return {
roster,
+ messageProjection: {
+ messages: [] as Array<{ role: "user"; createdAt: string }>,
+ lastMessageRole: "user",
+ hasMessages: true,
+ lastUserMessageAt: "2026-09-01T00:00:00.000Z",
+ },
threadShells: [] as Array<Record<string, unknown>>,
commands: {
create: Symbol("create"),
@@ -59,6 +65,9 @@ vi.mock("../../hooks/useSettings", () => ({
vi.mock("../../modelSelection", () => ({
resolveAppModelSelectionState: () => ({ provider: "codex", model: "gpt" }),
}));
+vi.mock("./botConversationMessageProjection", () => ({
+ useBotConversationMessageProjection: () => mocks.messageProjection,
+}));
vi.mock("../../state/entities", () => ({
useProjects: () => [{ environmentId: "env-a", id: "project-1", defaultModelSelection: null }],
useThreadShells: () => mocks.threadShells,
@@ -69,7 +78,6 @@ vi.mock("../../state/entities", () => ({
(shell) => shell.environmentId === ref.environmentId && shell.id === ref.threadId,
)) ??
null,
- useThreadMessages: () => [{ role: "user", createdAt: "2026-09-01T00:00:00.000Z" }],
useThreadActivities: () => [],
readEnvironmentSupportsFileAttachments: () => true,
}));
@@ -135,6 +143,8 @@ const startedThreadIds = () =>
beforeEach(() => {
hooks.reset();
vi.clearAllMocks();
+ mocks.messageProjection.messages = [{ role: "user", createdAt: "2026-09-01T00:00:00.000Z" }];
+ mocks.messageProjection.hasMessages = true;
mocks.roster.chatPathByBotId = {};
mocks.roster.openChatByBotId = {};
mocks.threadShells = [
@@ -146,6 +156,19 @@ beforeEach(() => {
});
describe("New chat while another chat is opened", () => {
+ it("allows a new chat after a hidden routine request but not for empty history", async () => {
+ mocks.messageProjection.messages = [];
+ expect(render().canStartNewChat).toBe(true);
+ const finishCreate = deferredCreate();
+ const creating = render().startNewChat();
+ finishCreate();
+ expect(await creating).toBe(true);
+ expect(mocks.createThread).toHaveBeenCalledTimes(1);
+
+ mocks.messageProjection.hasMessages = false;
+ expect(render().canStartNewChat).toBe(false);
+ });
+
it("keeps the opened chat and sends into it when creation finishes later", async () => {
const finishCreate = deferredCreate();
const creating = render().startNewChat();
diff --git a/apps/web/src/components/roster/useBotThreadRuntime.test.ts b/apps/web/src/components/roster/useBotThreadRuntime.test.ts
index 4d510e886..d54e8def0 100644
--- a/apps/web/src/components/roster/useBotThreadRuntime.test.ts
+++ b/apps/web/src/components/roster/useBotThreadRuntime.test.ts
@@ -4,6 +4,7 @@ import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
import { reactHookHarness as hooks } from "../../test/reactHookHarness";
import { useBotThreadRuntime } from "./useBotThreadRuntime";
import { useRosterPendingApproval } from "./useRosterPendingApproval";
+import type { BotConversationMessageProjection } from "./botConversationMessageProjection";
const mocks = vi.hoisted(() => ({
derivePendingApprovals: vi.fn(),
@@ -13,6 +14,12 @@ const mocks = vi.hoisted(() => ({
primaryEnvironmentId: null as EnvironmentId | null,
threadShells: [] as Array<Record<string, unknown>>,
threadShell: null as Record<string, unknown> | null,
+ messageProjection: {
+ messages: [],
+ lastMessageRole: null,
+ hasMessages: false,
+ lastUserMessageAt: null,
+ } as BotConversationMessageProjection,
}));
vi.mock("react", async (importOriginal) => {
@@ -57,6 +64,9 @@ vi.mock("../../session-logic", () => ({
derivePendingUserInputs: () => [],
}));
vi.mock("../Sidebar.logic", () => ({ sortScopedProjectsForSidebar: () => [] }));
+vi.mock("./botConversationMessageProjection", () => ({
+ useBotConversationMessageProjection: () => mocks.messageProjection,
+}));
vi.mock("./rosterStore", () => ({
useRosterStore: (
selector: (state: { bots: []; chatPathByBotId: {}; openChatByBotId: {} }) => unknown,
@@ -69,6 +79,12 @@ beforeEach(() => {
mocks.primaryEnvironmentId = null;
mocks.threadShells = [];
mocks.threadShell = null;
+ mocks.messageProjection = {
+ messages: [],
+ lastMessageRole: null,
+ hasMessages: false,
+ lastUserMessageAt: null,
+ };
mocks.derivePendingApprovals.mockReturnValue([]);
mocks.useAtomCommand.mockReturnValue(mocks.command);
mocks.command.mockResolvedValue({ _tag: "Success", value: undefined });
@@ -113,6 +129,62 @@ describe("bot runtime approval ownership", () => {
});
describe("bot runtime errors", () => {
+ it("reports a newer routine startup failure instead of the previous failed turn", () => {
+ mocks.primaryEnvironmentId = EnvironmentId.make("env-a");
+ mocks.threadShells = [
+ {
+ environmentId: mocks.primaryEnvironmentId,
+ id: ThreadId.make("thread-1"),
+ botId: "bot-1",
+ archivedAt: null,
+ updatedAt: "2026-09-18T01:00:00.000Z",
+ },
+ ];
+ mocks.threadShell = {
+ ...mocks.threadShells[0],
+ latestTurn: {
+ state: "error",
+ requestedAt: "2026-09-18T00:00:00.000Z",
+ errorMessage: "Previous turn failed.",
+ },
+ session: { status: "error", lastError: "Routine failed before starting." },
+ };
+ mocks.messageProjection = {
+ messages: [],
+ lastMessageRole: "user",
+ hasMessages: true,
+ lastUserMessageAt: "2026-09-18T01:00:00.000Z",
+ };
+ hooks.beginRender();
+ const runtime = useBotThreadRuntime("bot-1", null);
+ expect(runtime.turnFailure?.message).toBe("Routine failed before starting.");
+ });
+
+ it("keeps resume available when the narrow message projection ends with user input", () => {
+ const environmentId = EnvironmentId.make("env-a");
+ mocks.primaryEnvironmentId = environmentId;
+ mocks.threadShells = [
+ {
+ environmentId,
+ id: ThreadId.make("thread-1"),
+ botId: "bot-1",
+ updatedAt: "2026-09-13T00:00:00.000Z",
+ archivedAt: null,
+ },
+ ];
+ mocks.threadShell = {
+ ...mocks.threadShells[0],
+ session: { status: "error" },
+ latestTurn: null,
+ };
+ mocks.messageProjection = { ...mocks.messageProjection, lastMessageRole: "user" };
+
+ hooks.beginRender();
+ const runtime = useBotThreadRuntime("bot-1", null);
+
+ expect(runtime.canResume).toBe(true);
+ });
+
it("surfaces the persisted provider error for a failed turn", () => {
const environmentId = EnvironmentId.make("env-a");
mocks.primaryEnvironmentId = environmentId;
diff --git a/apps/web/src/components/roster/useBotThreadRuntime.ts b/apps/web/src/components/roster/useBotThreadRuntime.ts
index e45c5384a..1a84b476b 100644
--- a/apps/web/src/components/roster/useBotThreadRuntime.ts
+++ b/apps/web/src/components/roster/useBotThreadRuntime.ts
@@ -1,3 +1,4 @@
+import { useBotConversationMessageProjection } from "./botConversationMessageProjection";
import { useAtomValue } from "@effect/atom-react";
import { scopeThreadRef } from "@akeru/client-runtime/environment";
import {
@@ -20,7 +21,6 @@ import {
useProjects,
readEnvironmentSupportsFileAttachments,
useThreadActivities,
- useThreadMessages,
useThreadShells,
} from "../../state/entities";
import { environmentBotsAtom } from "../../state/bots";
@@ -166,7 +166,8 @@ export function useBotThreadRuntime(botId: string, effectiveModelSelection: Mode
bootstrapped,
openThreadId,
);
- const messages = useThreadMessages(linkedThreadRef);
+ const { messages, lastMessageRole, hasMessages, lastUserMessageAt } =
+ useBotConversationMessageProjection(linkedThreadRef);
const activities = useThreadActivities(linkedThreadRef);
const openedAuthorizationActivitiesRef = useRef(new Set<string>());
useEffect(() => {
@@ -248,7 +249,7 @@ export function useBotThreadRuntime(botId: string, effectiveModelSelection: Mode
rememberedThread?.session?.status === "stopped") &&
(rememberedThread?.latestTurn?.state === "error" ||
rememberedThread?.latestTurn?.state === "interrupted" ||
- (rememberedThread?.latestTurn === null && messages?.at(-1)?.role === "user"));
+ (rememberedThread?.latestTurn === null && lastMessageRole === "user"));
const resume = useCallback(async (): Promise<boolean> => {
if (!linkedThreadRef || !canResume || resuming) return false;
setResuming(true);
@@ -353,11 +354,7 @@ export function useBotThreadRuntime(botId: string, effectiveModelSelection: Mode
// A fresh chat only makes sense once the current one has a message; an empty
// chat is already fresh, and creating another would leave it behind.
const canStartNewChat =
- botReady &&
- activeProject !== null &&
- !sending &&
- linkedThreadRef !== null &&
- (messages?.length ?? 0) > 0;
+ botReady && activeProject !== null && !sending && linkedThreadRef !== null && hasMessages;
const startNewChat = useCallback(async (): Promise<boolean> => {
if (!canStartNewChat || startingNewChatRef.current) return false;
// A created chat waits here until its shell arrives; another click would leave it empty.
@@ -699,13 +696,12 @@ export function useBotThreadRuntime(botId: string, effectiveModelSelection: Mode
submitPendingUserInput,
]);
- const lastUserMessageAt = messages?.findLast((message) => message.role === "user")?.createdAt;
const session = rememberedThread?.session ?? null;
const turnFailure = latestBotThreadFailure({
activities,
latestTurn: rememberedThread?.latestTurn ?? null,
session,
- lastUserMessageAt: lastUserMessageAt ?? null,
+ lastUserMessageAt,
});
const failure: BotThreadFailure | null =
error ??
diff --git a/apps/web/src/components/roster/useGroupThreadRuntime.test.ts b/apps/web/src/components/roster/useGroupThreadRuntime.test.ts
index bcf1db271..29b77c8b1 100644
--- a/apps/web/src/components/roster/useGroupThreadRuntime.test.ts
+++ b/apps/web/src/components/roster/useGroupThreadRuntime.test.ts
@@ -1,3 +1,6 @@
+vi.mock("./botConversationMessageProjection", () => ({
+ useBotConversationMessageProjection: () => mocks.messageProjection,
+}));
import { BotId, EnvironmentId, ThreadId } from "@akeru/contracts";
import { DEFAULT_UNIFIED_SETTINGS } from "@akeru/contracts/settings";
import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
@@ -6,8 +9,15 @@ import { makeComposerTestProvider } from "../../test/composerTestProvider";
import { reactHookHarness as hooks } from "../../test/reactHookHarness";
import type { Bot, Group } from "./types";
import { useGroupThreadRuntime } from "./useGroupThreadRuntime";
+import type { BotConversationMessageProjection } from "./botConversationMessageProjection";
const mocks = vi.hoisted(() => ({
+ messageProjection: {
+ messages: [],
+ lastMessageRole: null,
+ hasMessages: false,
+ lastUserMessageAt: null,
+ } as BotConversationMessageProjection,
primaryEnvironmentId: "env-a" as EnvironmentId,
groupAtom: Symbol("groups"),
startTurnAtom: Symbol("start-turn"),
@@ -82,6 +92,12 @@ vi.mock("./rosterStore", () => ({
beforeEach(() => {
hooks.reset();
+ mocks.messageProjection = {
+ messages: [],
+ lastMessageRole: null,
+ hasMessages: false,
+ lastUserMessageAt: null,
+ };
mocks.threadShells = [];
mocks.threadShell = null;
mocks.serverGroups = [];
@@ -93,6 +109,36 @@ beforeEach(() => {
});
describe("group runtime errors", () => {
+ it("reports a newer routine startup failure instead of the previous failed turn", () => {
+ mocks.threadShells = [
+ {
+ environmentId: mocks.primaryEnvironmentId,
+ id: ThreadId.make("thread-1"),
+ groupId: "group-1",
+ archivedAt: null,
+ updatedAt: "2026-09-18T01:00:00.000Z",
+ },
+ ];
+ mocks.threadShell = {
+ ...mocks.threadShells[0],
+ latestTurn: {
+ state: "error",
+ requestedAt: "2026-09-18T00:00:00.000Z",
+ errorMessage: "Previous turn failed.",
+ },
+ session: { status: "error", lastError: "Routine failed before starting." },
+ };
+ mocks.messageProjection = {
+ messages: [],
+ lastMessageRole: "user",
+ hasMessages: true,
+ lastUserMessageAt: "2026-09-18T01:00:00.000Z",
+ };
+ hooks.beginRender();
+ const runtime = useGroupThreadRuntime("group-1");
+ expect(runtime.turnFailure?.message).toBe("Routine failed before starting.");
+ });
+
it("allows a configured group bot when the app default has no provider", () => {
mocks.groups = [
{
diff --git a/apps/web/src/components/roster/useGroupThreadRuntime.ts b/apps/web/src/components/roster/useGroupThreadRuntime.ts
index 446166893..2d9a197f4 100644
--- a/apps/web/src/components/roster/useGroupThreadRuntime.ts
+++ b/apps/web/src/components/roster/useGroupThreadRuntime.ts
@@ -1,3 +1,4 @@
+import { useBotConversationMessageProjection } from "./botConversationMessageProjection";
import { useAtomValue } from "@effect/atom-react";
import { scopeThreadRef } from "@akeru/client-runtime/environment";
import {
@@ -28,7 +29,6 @@ import {
useProjects,
readEnvironmentSupportsFileAttachments,
useThreadActivities,
- useThreadMessages,
useThreadShell,
useThreadShells,
} from "../../state/entities";
@@ -156,7 +156,8 @@ export function useGroupThreadRuntime(groupId: string) {
linkedThreadRef,
bootstrapped,
);
- const messages = useThreadMessages(linkedThreadRef);
+ const { messages, lastMessageRole, lastUserMessageAt } =
+ useBotConversationMessageProjection(linkedThreadRef);
const activities = useThreadActivities(linkedThreadRef);
const pendingUserInputs = useMemo(() => derivePendingUserInputs(activities), [activities]);
const defaultProject = useMemo(
@@ -208,7 +209,7 @@ export function useGroupThreadRuntime(groupId: string) {
rememberedThread?.session?.status === "stopped") &&
(rememberedThread?.latestTurn?.state === "error" ||
rememberedThread?.latestTurn?.state === "interrupted" ||
- (rememberedThread?.latestTurn === null && messages?.at(-1)?.role === "user"));
+ (rememberedThread?.latestTurn === null && lastMessageRole === "user"));
const resume = useCallback(async (): Promise<boolean> => {
if (!linkedThreadRef || !canResume || resuming) return false;
setResuming(true);
@@ -534,7 +535,7 @@ export function useGroupThreadRuntime(groupId: string) {
activities,
latestTurn: rememberedThread?.latestTurn ?? null,
session,
- lastUserMessageAt: messages?.findLast((message) => message.role === "user")?.createdAt ?? null,
+ lastUserMessageAt,
});
const failure: BotThreadFailure | null =
error ??
diff --git a/docs/internals/overview.md b/docs/internals/overview.md
index e6a9ff2c2..23bef13b9 100644
--- a/docs/internals/overview.md
+++ b/docs/internals/overview.md
@@ -100,7 +100,8 @@ does not define turn end.
## Drainable workers
-Follow-up work runs asynchronously in queue-backed workers built on [`DrainableWorker`][worker]:
+Follow-up work runs asynchronously in queue-backed workers built on [`DrainableWorker`][worker]
+or the keyed provider worker:
[`ProviderRuntimeIngestion`][ingest] normalizes provider runtime streams into orchestration commands,
[`ProviderCommandReactor`][cmd] dispatches provider calls in response to intent events, and
[`CheckpointReactor`][checkpoint] captures and reverts workspace checkpoints.
@@ -110,6 +111,19 @@ Follow-up work runs asynchronously in queue-backed workers built on [`DrainableW
count reaches zero, so a test can await "queue empty and current item finished" instead of sleeping.
Each of the three services exposes `drain` for exactly this.
+`ProviderCommandReactor` uses a keyed worker with four concurrent lanes. Commands for the same
+thread run in FIFO order; unrelated threads can progress while session setup waits. Its drain
+retains the subscription sequence barrier and repeats when worker execution publishes more events.
+
+Workspace entry refreshes run in the background with at most two concurrent scans. Requests for
+the same workspace coalesce into generations. Entry searches and lists await the latest requested
+generation, while checkpoint publication only queues the refresh. Browsing and content search
+remain separate workspace services.
+
+Mastra attachment preparation reads bytes asynchronously in attachment order. Before admitting the
+turn, the controller checks that the session is still current and has not been interrupted or
+stopped during preparation.
+
Runtime receipts are a test-only mechanism. `RuntimeReceiptBusLive` in
[`RuntimeReceiptBus.ts`][receipts] publishes nothing; only the test layer is PubSub-backed. Do not
build production behavior on receipts.