Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

perf: add cache-backed pagination and fix newestMessageId regression

Gus9432d763beea
diff --git a/src/web/src/components/agent-chat/agent-chat-view.tsx b/src/web/src/components/agent-chat/agent-chat-view.tsx
index 28770862c..b6d4bd433 100644
--- a/src/web/src/components/agent-chat/agent-chat-view.tsx
+++ b/src/web/src/components/agent-chat/agent-chat-view.tsx
@@ -32,7 +32,7 @@ import {
flagMessage as apiFlagMessage,
unflagMessage as apiUnflagMessage,
} from "@/lib/api";
-import { appendCachedMessage, mergeCachedMessages } from "@/lib/chat-cache";
+import { appendCachedMessage, getCachedMessages, getCachedMessagesBefore, mergeCachedMessages } from "@/lib/chat-cache";
import type { PreviousConversation, TraceTask } from "@/lib/api";
import type { Artifact, Conversation, Issue, IssueComment, Message, TaskApi as Task, TaskMessage, WsMessage } from "@alook/shared";
import { useAgentContext } from "@/contexts/agent-context";
@@ -373,11 +373,9 @@ export function AgentChatView({
const { increment: flagIncrement, decrement: flagDecrement, refresh: flagRefresh } = useFlagCount();
- const { cachedMessages, isFromCache, writeToCache } = useCachedMessages(targetConvId ?? null, workspaceId);
- const cachedMessagesRef = useRef(cachedMessages);
- const isFromCacheRef = useRef(isFromCache);
+ const { writeToCache } = useCachedMessages(targetConvId ?? null, workspaceId);
const writeToCacheRef = useRef(writeToCache);
- useEffect(() => { cachedMessagesRef.current = cachedMessages; isFromCacheRef.current = isFromCache; writeToCacheRef.current = writeToCache; }, [cachedMessages, isFromCache, writeToCache]);
+ useEffect(() => { writeToCacheRef.current = writeToCache; }, [writeToCache]);
useEffect(() => {
setChannelAgentId(agentId);
@@ -484,31 +482,28 @@ export function AgentChatView({
pollRef.current = null;
pollTaskIdRef.current = null;
let ignore = false;
- const cached = cachedMessagesRef.current;
- const hasCacheHit = isFromCacheRef.current && cached && cached.length > 0;
- queueMicrotask(() => {
- if (ignore) return;
- setLoading(!hasCacheHit);
- initialScrollDone.current = false;
- setActiveTask(null);
- setTaskMessages([]);
- setBufferedMessages([]);
- setPendingFilesByMessage(new Map());
- setNapMarkers([]);
- setStepCounts({});
- setPreviousConversations([]);
- setHasMoreConversations(false);
- oldestConversationCursorRef.current = null;
- setInput(localStorage.getItem(`chat-draft:${agentId}:${targetConvId ?? 'default'}`) ?? "");
- if (hasCacheHit) {
- setMessages(cached!);
- } else {
- setMessages([]);
- }
- });
+ setLoading(true);
+ initialScrollDone.current = false;
+ setActiveTask(null);
+ setTaskMessages([]);
+ setBufferedMessages([]);
+ setPendingFilesByMessage(new Map());
+ setNapMarkers([]);
+ setStepCounts({});
+ setPreviousConversations([]);
+ setHasMoreConversations(false);
+ oldestConversationCursorRef.current = null;
+ setInput(localStorage.getItem(`chat-draft:${agentId}:${targetConvId ?? 'default'}`) ?? "");
+ setMessages([]);
async function load() {
try {
if (targetConvId) {
+ const cached = await getCachedMessages(targetConvId, workspaceId);
+ if (ignore) return;
+ if (cached && cached.length > 0) {
+ setMessages(cached);
+ setLoading(false);
+ }
try {
const [conv, msgsResult, arts, buffered] = await Promise.all([
getConversation(targetConvId, workspaceId),
@@ -790,14 +785,24 @@ export function AgentChatView({
// --- Phase 1: Load from current/paginating conversation ---
if (canLoadMoreInConv) {
- const result = await listMessages(paginatingConvId, workspaceId, {
- limit: MESSAGE_LIMIT,
- before: oldest!.created_at,
- beforeId: oldest!.id,
- });
- phase1Messages = result.messages;
- remaining -= result.messages.length;
- lastHasMore = result.has_more;
+ const cached = paginatingConvId === conversation.id
+ ? await getCachedMessagesBefore(paginatingConvId, oldest!.created_at, oldest!.id, MESSAGE_LIMIT, workspaceId)
+ : null;
+
+ if (cached) {
+ phase1Messages = cached.messages;
+ remaining -= cached.messages.length;
+ lastHasMore = cached.hasMore;
+ } else {
+ const result = await listMessages(paginatingConvId, workspaceId, {
+ limit: MESSAGE_LIMIT,
+ before: oldest!.created_at,
+ beforeId: oldest!.id,
+ });
+ phase1Messages = result.messages;
+ remaining -= result.messages.length;
+ lastHasMore = result.has_more;
+ }
}
// --- Phase 2: If current conv is exhausted AND still have quota, load from previous convs ---
@@ -980,7 +985,10 @@ export function AgentChatView({
if (isStale) {
// Stale poll — still merge messages but don't touch activeTask or polling
listMessages(conversationId, workspaceId)
- .then(({ messages: latest }) => setMessages((prev) => mergeMessages(prev, latest)))
+ .then(({ messages: latest }) => {
+ setMessages((prev) => mergeMessages(prev, latest));
+ mergeCachedMessages(conversationId, latest, null, workspaceId).catch(() => {});
+ })
.catch(() => { });
return;
}
@@ -1002,6 +1010,7 @@ export function AgentChatView({
listArtifacts(conversationId, workspaceId).catch(() => null),
]);
setMessages((prev) => mergeMessages(prev, latestResult.messages));
+ mergeCachedMessages(conversationId, latestResult.messages, null, workspaceId).catch(() => {});
if (arts) setArtifacts(arts);
setActiveTask(task);
} catch {
@@ -1031,6 +1040,7 @@ export function AgentChatView({
if (nextTask && nextTask.id !== taskId) {
const { messages: latestMsgs } = await listMessages(conversationId, workspaceId);
setMessages((prev) => mergeMessages(prev, latestMsgs));
+ mergeCachedMessages(conversationId, latestMsgs, null, workspaceId).catch(() => {});
setActiveTask(nextTask);
setTaskMessages([]);
startPollingRef.current?.(nextTask.id, conversationId);
@@ -1088,7 +1098,10 @@ export function AgentChatView({
}
if (msg.type === "task.created" && msg.conversationId === conversation?.id) {
listMessages(msg.conversationId, workspaceId)
- .then(({ messages: latest }) => setMessages((prev) => mergeMessages(prev, latest)))
+ .then(({ messages: latest }) => {
+ setMessages((prev) => mergeMessages(prev, latest));
+ mergeCachedMessages(msg.conversationId, latest, null, workspaceId).catch(() => {});
+ })
.catch(() => {});
const task = msg.task as Task;
activeTaskIdRef.current = task.id;
@@ -1101,6 +1114,9 @@ export function AgentChatView({
setMessages((prev) => mergeMessages(prev, [msg.message]));
appendCachedMessage(msg.conversationId, msg.message, workspaceId).catch(() => {});
}
+ if (msg.type === "task.updated" && msg.taskId === activeTaskIdRef.current) {
+ setActiveTask((prev) => prev ? { ...prev, status: msg.status } : prev);
+ }
if (msg.type === "artifact.uploaded" && msg.conversationId === conversation?.id) {
setArtifacts((prev) => {
if (prev.some((a) => a.id === msg.artifact.id)) return prev;
@@ -1114,9 +1130,11 @@ export function AgentChatView({
listBufferedMessages(msg.conversationId, workspaceId)
.then(setBufferedMessages).catch(() => {});
listMessages(msg.conversationId, workspaceId)
- .then(({ messages: latest }) => setMessages((prev) => mergeMessages(prev, latest)))
+ .then(({ messages: latest }) => {
+ setMessages((prev) => mergeMessages(prev, latest));
+ mergeCachedMessages(msg.conversationId, latest, null, workspaceId).catch(() => {});
+ })
.catch(() => { });
- appendCachedMessage(msg.conversationId, msg.message, workspaceId).catch(() => {});
const task = msg.task as Task;
activeTaskIdRef.current = task.id;
setActiveTask(task);
@@ -1288,6 +1306,7 @@ export function AgentChatView({
listBufferedMessages(conversation.id, workspaceId),
]);
setMessages((prev) => mergeMessages(prev, latestResult.messages));
+ mergeCachedMessages(conversation.id, latestResult.messages, null, workspaceId).catch(() => {});
setBufferedMessages(latestBuffered);
setActiveTask(cancelled as Task);
setTaskMessages([]);
diff --git a/src/web/src/lib/chat-cache.test.ts b/src/web/src/lib/chat-cache.test.ts
index 5b52672e1..53b165ed0 100644
--- a/src/web/src/lib/chat-cache.test.ts
+++ b/src/web/src/lib/chat-cache.test.ts
@@ -4,6 +4,7 @@ import type { Message } from "@alook/shared";
import {
openCacheDB,
getCachedMessages,
+ getCachedMessagesBefore,
mergeCachedMessages,
appendCachedMessage,
removeCachedMessage,
@@ -81,6 +82,27 @@ describe("chat-cache", () => {
expect(cached!.map((m) => m.id)).toEqual(["m1", "m2", "m3"]);
});
+ it("does not regress newestMessageId when merging older messages", async () => {
+ const newer = [
+ makeMessage({ id: "m3", conversation_id: "conv_1", created_at: "2024-01-01T00:02:00Z" }),
+ makeMessage({ id: "m4", conversation_id: "conv_1", created_at: "2024-01-01T00:03:00Z" }),
+ ];
+ await mergeCachedMessages("conv_1", newer, true, WORKSPACE_ID);
+
+ const metaBefore = await getCacheMeta("conv_1", WORKSPACE_ID);
+ expect(metaBefore!.newestMessageId).toBe("m4");
+
+ const older = [
+ makeMessage({ id: "m1", conversation_id: "conv_1", created_at: "2024-01-01T00:00:00Z" }),
+ makeMessage({ id: "m2", conversation_id: "conv_1", created_at: "2024-01-01T00:01:00Z" }),
+ ];
+ await mergeCachedMessages("conv_1", older, null, WORKSPACE_ID);
+
+ const metaAfter = await getCacheMeta("conv_1", WORKSPACE_ID);
+ expect(metaAfter!.newestMessageId).toBe("m4");
+ expect(metaAfter!.messageCount).toBe(4);
+ });
+
it("filters out buffered messages", async () => {
const msgs = [
makeMessage({ id: "m1", conversation_id: "conv_1", status: "active" }),
@@ -244,6 +266,157 @@ describe("chat-cache", () => {
});
});
+ describe("getCachedMessagesBefore", () => {
+ it("returns older messages from cache correctly", async () => {
+ const msgs = Array.from({ length: 10 }, (_, i) =>
+ makeMessage({
+ id: `m${i + 1}`,
+ conversation_id: "conv_1",
+ created_at: `2024-01-01T00:0${i}:00Z`,
+ })
+ );
+ await mergeCachedMessages("conv_1", msgs, false, WORKSPACE_ID);
+
+ const result = await getCachedMessagesBefore("conv_1", "2024-01-01T00:06:00Z", "m7", 10, WORKSPACE_ID);
+ expect(result).not.toBeNull();
+ expect(result!.messages.map((m) => m.id)).toEqual(["m1", "m2", "m3", "m4", "m5", "m6"]);
+ });
+
+ it("respects limit parameter", async () => {
+ const msgs = Array.from({ length: 20 }, (_, i) =>
+ makeMessage({
+ id: `m${String(i + 1).padStart(2, "0")}`,
+ conversation_id: "conv_1",
+ created_at: `2024-01-01T00:${String(i).padStart(2, "0")}:00Z`,
+ })
+ );
+ await mergeCachedMessages("conv_1", msgs, false, WORKSPACE_ID);
+
+ const result = await getCachedMessagesBefore("conv_1", "2024-01-01T00:19:00Z", "m20", 5, WORKSPACE_ID);
+ expect(result).not.toBeNull();
+ expect(result!.messages).toHaveLength(5);
+ expect(result!.messages.map((m) => m.id)).toEqual(["m15", "m16", "m17", "m18", "m19"]);
+ expect(result!.hasMore).toBe(true);
+ });
+
+ it("hasMore is false when results exactly equal limit and meta.hasMore=false", async () => {
+ const msgs = Array.from({ length: 6 }, (_, i) =>
+ makeMessage({
+ id: `m${i + 1}`,
+ conversation_id: "conv_1",
+ created_at: `2024-01-01T00:0${i}:00Z`,
+ })
+ );
+ await mergeCachedMessages("conv_1", msgs, false, WORKSPACE_ID);
+
+ const result = await getCachedMessagesBefore("conv_1", "2024-01-01T00:05:00Z", "m6", 5, WORKSPACE_ID);
+ expect(result).not.toBeNull();
+ expect(result!.messages).toHaveLength(5);
+ expect(result!.hasMore).toBe(false);
+ });
+
+ it("returns null when cache is incomplete (hasMore=true and fewer results than limit)", async () => {
+ const msgs = [
+ makeMessage({ id: "m1", conversation_id: "conv_1", created_at: "2024-01-01T00:00:00Z" }),
+ makeMessage({ id: "m2", conversation_id: "conv_1", created_at: "2024-01-01T00:01:00Z" }),
+ makeMessage({ id: "m3", conversation_id: "conv_1", created_at: "2024-01-01T00:02:00Z" }),
+ ];
+ await mergeCachedMessages("conv_1", msgs, true, WORKSPACE_ID);
+
+ const result = await getCachedMessagesBefore("conv_1", "2024-01-01T00:02:00Z", "m3", 10, WORKSPACE_ID);
+ expect(result).toBeNull();
+ });
+
+ it("returns partial results when cache is complete (hasMore=false)", async () => {
+ const msgs = [
+ makeMessage({ id: "m1", conversation_id: "conv_1", created_at: "2024-01-01T00:00:00Z" }),
+ makeMessage({ id: "m2", conversation_id: "conv_1", created_at: "2024-01-01T00:01:00Z" }),
+ makeMessage({ id: "m3", conversation_id: "conv_1", created_at: "2024-01-01T00:02:00Z" }),
+ ];
+ await mergeCachedMessages("conv_1", msgs, false, WORKSPACE_ID);
+
+ const result = await getCachedMessagesBefore("conv_1", "2024-01-01T00:02:00Z", "m3", 10, WORKSPACE_ID);
+ expect(result).not.toBeNull();
+ expect(result!.messages.map((m) => m.id)).toEqual(["m1", "m2"]);
+ expect(result!.hasMore).toBe(false);
+ });
+
+ it("returns null for unknown conversation", async () => {
+ const result = await getCachedMessagesBefore("nonexistent", "2024-01-01T00:00:00Z", "x", 10, WORKSPACE_ID);
+ expect(result).toBeNull();
+ });
+
+ it("handles equal timestamps with ID tiebreaker", async () => {
+ const msgs = [
+ makeMessage({ id: "aaa", conversation_id: "conv_1", created_at: "2024-01-01T00:00:00Z" }),
+ makeMessage({ id: "bbb", conversation_id: "conv_1", created_at: "2024-01-01T00:00:00Z" }),
+ makeMessage({ id: "ccc", conversation_id: "conv_1", created_at: "2024-01-01T00:00:00Z" }),
+ ];
+ await mergeCachedMessages("conv_1", msgs, false, WORKSPACE_ID);
+
+ const result = await getCachedMessagesBefore("conv_1", "2024-01-01T00:00:00Z", "ccc", 10, WORKSPACE_ID);
+ expect(result).not.toBeNull();
+ expect(result!.messages.map((m) => m.id)).toEqual(["aaa", "bbb"]);
+ });
+
+ it("filters out buffered and temp- messages", async () => {
+ const db = await openCacheDB(WORKSPACE_ID)!;
+ const msgs = [
+ makeMessage({ id: "m1", conversation_id: "conv_1", created_at: "2024-01-01T00:00:00Z" }),
+ makeMessage({ id: "m2", conversation_id: "conv_1", created_at: "2024-01-01T00:01:00Z", status: "buffered" }),
+ makeMessage({ id: "temp-1", conversation_id: "conv_1", created_at: "2024-01-01T00:02:00Z" }),
+ makeMessage({ id: "m3", conversation_id: "conv_1", created_at: "2024-01-01T00:03:00Z" }),
+ makeMessage({ id: "m4", conversation_id: "conv_1", created_at: "2024-01-01T00:04:00Z" }),
+ ];
+ // Write directly to include buffered/temp that mergeCachedMessages would filter
+ for (const msg of msgs) {
+ await db.put("messages", msg);
+ }
+ await db.put("cache_meta", {
+ conversation_id: "conv_1",
+ lastFetchedAt: Date.now(),
+ lastAccessedAt: Date.now(),
+ messageCount: 5,
+ newestMessageId: "m4",
+ hasMore: false,
+ });
+
+ const result = await getCachedMessagesBefore("conv_1", "2024-01-01T00:04:00Z", "m4", 10, WORKSPACE_ID);
+ expect(result).not.toBeNull();
+ expect(result!.messages.map((m) => m.id)).toEqual(["m1", "m3"]);
+ });
+
+ it("correctly excludes the cursor message itself", async () => {
+ const msgs = [
+ makeMessage({ id: "m1", conversation_id: "conv_1", created_at: "2024-01-01T00:00:00Z" }),
+ makeMessage({ id: "m2", conversation_id: "conv_1", created_at: "2024-01-01T00:01:00Z" }),
+ makeMessage({ id: "m3", conversation_id: "conv_1", created_at: "2024-01-01T00:02:00Z" }),
+ ];
+ await mergeCachedMessages("conv_1", msgs, false, WORKSPACE_ID);
+
+ const result = await getCachedMessagesBefore("conv_1", "2024-01-01T00:02:00Z", "m3", 10, WORKSPACE_ID);
+ expect(result).not.toBeNull();
+ expect(result!.messages.every((m) => m.id !== "m3")).toBe(true);
+ });
+
+ it("no meta corruption on cache-hit path", async () => {
+ const msgs = [
+ makeMessage({ id: "m1", conversation_id: "conv_1", created_at: "2024-01-01T00:00:00Z" }),
+ makeMessage({ id: "m2", conversation_id: "conv_1", created_at: "2024-01-01T00:01:00Z" }),
+ makeMessage({ id: "m3", conversation_id: "conv_1", created_at: "2024-01-01T00:02:00Z" }),
+ ];
+ await mergeCachedMessages("conv_1", msgs, false, WORKSPACE_ID);
+
+ const metaBefore = await getCacheMeta("conv_1", WORKSPACE_ID);
+ await getCachedMessagesBefore("conv_1", "2024-01-01T00:02:00Z", "m3", 10, WORKSPACE_ID);
+ const metaAfter = await getCacheMeta("conv_1", WORKSPACE_ID);
+
+ expect(metaAfter!.messageCount).toBe(metaBefore!.messageCount);
+ expect(metaAfter!.hasMore).toBe(metaBefore!.hasMore);
+ expect(metaAfter!.newestMessageId).toBe(metaBefore!.newestMessageId);
+ });
+ });
+
describe("clearAllCache", () => {
it("removes everything", async () => {
await mergeCachedMessages(
diff --git a/src/web/src/lib/chat-cache.ts b/src/web/src/lib/chat-cache.ts
index 7ac43edcb..1c9ce1523 100644
--- a/src/web/src/lib/chat-cache.ts
+++ b/src/web/src/lib/chat-cache.ts
@@ -88,10 +88,62 @@ export async function getCachedMessages(conversationId: string, workspaceId?: st
}
}
+export async function getCachedMessagesBefore(
+ conversationId: string,
+ beforeCreatedAt: string,
+ beforeId: string,
+ limit: number,
+ workspaceId?: string
+): Promise<{ messages: Message[]; hasMore: boolean } | null> {
+ const p = getDB(workspaceId);
+ if (!p) return null;
+
+ try {
+ const db = await p;
+ const meta = await db.get("cache_meta", conversationId);
+ if (!meta) return null;
+
+ const range = IDBKeyRange.bound(
+ [conversationId, ""],
+ [conversationId, beforeCreatedAt],
+ false,
+ false
+ );
+
+ const allInRange = await db.getAllFromIndex("messages", "by-created", range);
+
+ const filtered = allInRange.filter((m) => {
+ if (m.status === "buffered" || m.id.startsWith("temp-")) return false;
+ if (m.created_at === beforeCreatedAt && m.id >= beforeId) return false;
+ return true;
+ });
+
+ filtered.sort((a, b) => {
+ const cmp = b.created_at.localeCompare(a.created_at);
+ if (cmp !== 0) return cmp;
+ return b.id.localeCompare(a.id);
+ });
+
+ const topN = filtered.slice(0, limit);
+
+ if (topN.length < limit && meta.hasMore) return null;
+
+ await db.put("cache_meta", { ...meta, lastAccessedAt: Date.now() });
+
+ const result = topN.reverse();
+ return {
+ messages: result,
+ hasMore: filtered.length > limit || meta.hasMore,
+ };
+ } catch {
+ return null;
+ }
+}
+
export async function mergeCachedMessages(
conversationId: string,
messages: Message[],
- hasMore: boolean,
+ hasMore: boolean | null,
workspaceId?: string
): Promise<void> {
const p = getDB(workspaceId);
@@ -116,17 +168,29 @@ export async function mergeCachedMessages(
const allKeys = await msgStore.index("by-conversation").getAllKeys(conversationId);
const now = Date.now();
- const newest = validMessages.reduce((a, b) =>
+ const newestInBatch = validMessages.reduce((a, b) =>
a.created_at > b.created_at ? a : b
);
+ const existingMeta = await metaStore.get(conversationId);
+ const resolvedHasMore = hasMore ?? existingMeta?.hasMore ?? true;
+
+ const newestMessageId =
+ existingMeta?.newestMessageId && existingMeta.newestMessageId !== newestInBatch.id
+ ? await (async () => {
+ const existing = await msgStore.get([conversationId, existingMeta.newestMessageId!]);
+ if (existing && existing.created_at > newestInBatch.created_at) return existing.id;
+ return newestInBatch.id;
+ })()
+ : newestInBatch.id;
+
const meta: CacheMeta = {
conversation_id: conversationId,
lastFetchedAt: now,
lastAccessedAt: now,
messageCount: allKeys.length,
- newestMessageId: newest.id,
- hasMore,
+ newestMessageId,
+ hasMore: resolvedHasMore,
};
await metaStore.put(meta);
@@ -150,18 +214,18 @@ export async function appendCachedMessage(
try {
const db = await p;
+ const meta = await db.get("cache_meta", conversationId);
+ if (!meta) return;
+
const existing = await db.get("messages", [conversationId, message.id]);
await db.put("messages", message);
- const meta = await db.get("cache_meta", conversationId);
- if (meta) {
- await db.put("cache_meta", {
- ...meta,
- lastAccessedAt: Date.now(),
- messageCount: existing ? meta.messageCount : meta.messageCount + 1,
- newestMessageId: message.id,
- });
- }
+ await db.put("cache_meta", {
+ ...meta,
+ lastAccessedAt: Date.now(),
+ messageCount: existing ? meta.messageCount : meta.messageCount + 1,
+ newestMessageId: message.id,
+ });
} catch {
// Graceful degradation
}
diff --git a/src/web/src/lib/services/task.ts b/src/web/src/lib/services/task.ts
index d19e4a1d9..5c274f97f 100644
--- a/src/web/src/lib/services/task.ts
+++ b/src/web/src/lib/services/task.ts
@@ -150,12 +150,25 @@ export class TaskService {
typeof payload?.output === "string" ? payload.output : "";
if (output) {
- await messageQueries.createMessage(this.db, {
+ const msg = await messageQueries.createMessage(this.db, {
conversationId: task.conversationId,
role: "assistant",
content: output,
taskId,
});
+
+ try {
+ const conversation = await conversationQueries.getConversation(this.db, task.conversationId, workspaceId);
+ if (conversation) {
+ broadcastToUser(conversation.userId, {
+ type: "conversation.message",
+ conversationId: task.conversationId,
+ message: messageToResponse(msg),
+ }).catch(() => {});
+ }
+ } catch {
+ // non-critical: don't let broadcast failure block task lifecycle
+ }
}
await this.reconcileAgentStatus(task.agentId, task.workspaceId);
@@ -178,12 +191,25 @@ export class TaskService {
}
if (error) {
- await messageQueries.createMessage(this.db, {
+ const msg = await messageQueries.createMessage(this.db, {
conversationId: task.conversationId,
role: "assistant",
content: `Error: ${error}`,
taskId,
});
+
+ try {
+ const conversation = await conversationQueries.getConversation(this.db, task.conversationId, workspaceId);
+ if (conversation) {
+ broadcastToUser(conversation.userId, {
+ type: "conversation.message",
+ conversationId: task.conversationId,
+ message: messageToResponse(msg),
+ }).catch(() => {});
+ }
+ } catch {
+ // non-critical: don't let broadcast failure block task lifecycle
+ }
}
await this.reconcileAgentStatus(task.agentId, task.workspaceId);