Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

perf(web): merge chat page init into single API call (#22)

Gener5c8f81074bcb
diff --git a/src/web/src/app/api/agents/[id]/chat-init/route.test.ts b/src/web/src/app/api/agents/[id]/chat-init/route.test.ts
new file mode 100644
index 000000000..93258502d
--- /dev/null
+++ b/src/web/src/app/api/agents/[id]/chat-init/route.test.ts
@@ -0,0 +1,277 @@
+import { NextRequest } from "next/server";
+
+vi.mock("@opennextjs/cloudflare", () => ({
+ getCloudflareContext: vi.fn(() => ({ env: { DB: {} } })),
+}));
+
+const mockGetAgent = vi.fn();
+const mockGetOrCreateAgentConversation = vi.fn();
+const mockListMessages = vi.fn();
+const mockListArtifactsByConversation = vi.fn();
+const mockListBufferedMessages = vi.fn();
+const mockGetActiveTaskByConversation = vi.fn();
+const mockListTaskMessages = vi.fn();
+const mockArtifactToResponse = vi.fn((r: any) => ({
+ id: r.id,
+ conversation_id: r.conversationId,
+ agent_id: r.agentId,
+ filename: r.filename,
+ content_type: r.contentType,
+ size: r.size,
+ source: r.source,
+ created_at: r.createdAt,
+}));
+
+vi.mock("@/lib/db", () => ({ getDb: vi.fn(() => ({})) }));
+
+vi.mock("@alook/shared", () => ({
+ createDb: vi.fn(() => ({})),
+ queries: {
+ agent: {
+ getAgent: (...args: unknown[]) => mockGetAgent(...args),
+ },
+ conversation: {
+ getOrCreateAgentConversation: (...args: unknown[]) =>
+ mockGetOrCreateAgentConversation(...args),
+ },
+ message: {
+ listMessages: (...args: unknown[]) => mockListMessages(...args),
+ listBufferedMessages: (...args: unknown[]) =>
+ mockListBufferedMessages(...args),
+ },
+ artifact: {
+ listArtifactsByConversation: (...args: unknown[]) =>
+ mockListArtifactsByConversation(...args),
+ artifactToResponse: (...args: unknown[]) =>
+ mockArtifactToResponse(...args),
+ },
+ task: {
+ getActiveTaskByConversation: (...args: unknown[]) =>
+ mockGetActiveTaskByConversation(...args),
+ },
+ taskMessage: {
+ listTaskMessages: (...args: unknown[]) =>
+ mockListTaskMessages(...args),
+ },
+ },
+}));
+
+vi.mock("@/lib/middleware/auth", () => ({
+ withAuth: vi.fn((handler: any) => async (req: any, ctx?: any) => {
+ const params =
+ ctx?.params instanceof Promise ? await ctx.params : ctx?.params;
+ return handler(req, { userId: "u1", email: "[email protected]", params });
+ }),
+}));
+
+vi.mock("@/lib/middleware/workspace", () => ({
+ withWorkspaceMember: vi.fn(async () => ({ workspaceId: "w1" })),
+}));
+
+vi.mock("@/lib/api/responses", () => ({
+ conversationToResponse: vi.fn((c: any) => ({
+ id: c.id,
+ agent_id: c.agentId,
+ title: c.title,
+ created_at: c.createdAt,
+ })),
+ messageToResponse: vi.fn((m: any) => ({
+ id: m.id,
+ conversation_id: m.conversationId,
+ role: m.role,
+ content: m.content,
+ task_id: m.taskId || null,
+ attachment_ids: null,
+ created_at: m.createdAt,
+ })),
+ taskToResponse: vi.fn((t: any) => ({
+ id: t.id,
+ status: t.status,
+ agent_id: t.agentId,
+ created_at: t.createdAt,
+ })),
+ taskMessageToResponse: vi.fn((m: any) => ({
+ id: m.id,
+ task_id: m.taskId,
+ seq: m.seq,
+ type: m.type,
+ content: m.content,
+ })),
+}));
+
+import { POST } from "./route";
+
+beforeEach(() => vi.clearAllMocks());
+
+const makeReq = () =>
+ new NextRequest("http://localhost/api/agents/a1/chat-init", {
+ method: "POST",
+ });
+const makeCtx = () => ({ params: Promise.resolve({ id: "a1" }) });
+
+const CONV = {
+ id: "c1",
+ agentId: "a1",
+ title: "Hello",
+ createdAt: "2024-01-01T00:00:00.000Z",
+};
+
+function setupDefaults() {
+ mockGetAgent.mockResolvedValue({ id: "a1", name: "Agent" });
+ mockGetOrCreateAgentConversation.mockResolvedValue(CONV);
+ mockListMessages.mockResolvedValue([]);
+ mockListArtifactsByConversation.mockResolvedValue([]);
+ mockListBufferedMessages.mockResolvedValue([]);
+ mockGetActiveTaskByConversation.mockResolvedValue(null);
+}
+
+describe("POST /api/agents/[id]/chat-init", () => {
+ it("returns all chat data in a single response", async () => {
+ const msg = {
+ id: "m1",
+ conversationId: "c1",
+ role: "user",
+ content: "hi",
+ taskId: null,
+ createdAt: "2024-01-01T00:00:00.000Z",
+ };
+ const artifact = {
+ id: "art1",
+ conversationId: "c1",
+ agentId: "a1",
+ filename: "test.png",
+ contentType: "image/png",
+ size: 100,
+ source: "agent",
+ createdAt: "2024-01-01T00:00:00.000Z",
+ };
+
+ mockGetAgent.mockResolvedValue({ id: "a1", name: "Agent" });
+ mockGetOrCreateAgentConversation.mockResolvedValue(CONV);
+ mockListMessages.mockResolvedValue([msg]);
+ mockListArtifactsByConversation.mockResolvedValue([artifact]);
+ mockListBufferedMessages.mockResolvedValue([]);
+ mockGetActiveTaskByConversation.mockResolvedValue(null);
+
+ const res = await POST(makeReq(), makeCtx());
+ const body = await res.json();
+
+ expect(res.status).toBe(200);
+ expect(body.conversation.id).toBe("c1");
+ expect(body.messages).toHaveLength(1);
+ expect(body.messages[0].id).toBe("m1");
+ expect(body.artifacts).toHaveLength(1);
+ expect(body.artifacts[0].id).toBe("art1");
+ expect(body.buffered_messages).toEqual([]);
+ expect(body.active_task).toBeNull();
+ expect(body.task_messages).toEqual([]);
+ expect(body.has_more_messages).toBe(false);
+ });
+
+ it("returns 404 for non-existent agent", async () => {
+ mockGetAgent.mockResolvedValue(null);
+
+ const res = await POST(makeReq(), makeCtx());
+ const body = await res.json();
+
+ expect(res.status).toBe(404);
+ expect(body.error).toBe("agent not found");
+ });
+
+ it("includes active task and task messages when task is running", async () => {
+ const task = {
+ id: "t1",
+ agentId: "a1",
+ runtimeId: "r1",
+ conversationId: "c1",
+ workspaceId: "w1",
+ prompt: "do stuff",
+ status: "running",
+ priority: 0,
+ dispatchedAt: null,
+ startedAt: "2024-01-01T00:00:00.000Z",
+ completedAt: null,
+ createdAt: "2024-01-01T00:00:00.000Z",
+ };
+ const tmsg = {
+ id: "tm1",
+ taskId: "t1",
+ seq: 1,
+ type: "text",
+ content: "working...",
+ };
+
+ setupDefaults();
+ mockGetActiveTaskByConversation.mockResolvedValue(task);
+ mockListTaskMessages.mockResolvedValue([tmsg]);
+
+ const res = await POST(makeReq(), makeCtx());
+ const body = await res.json();
+
+ expect(body.active_task).not.toBeNull();
+ expect(body.active_task.id).toBe("t1");
+ expect(body.task_messages).toHaveLength(1);
+ expect(body.task_messages[0].seq).toBe(1);
+ });
+
+ it("skips task messages for completed tasks", async () => {
+ const task = {
+ id: "t1",
+ agentId: "a1",
+ runtimeId: "r1",
+ conversationId: "c1",
+ workspaceId: "w1",
+ prompt: "do stuff",
+ status: "completed",
+ priority: 0,
+ dispatchedAt: null,
+ startedAt: null,
+ completedAt: "2024-01-01T00:01:00.000Z",
+ createdAt: "2024-01-01T00:00:00.000Z",
+ };
+
+ setupDefaults();
+ mockGetActiveTaskByConversation.mockResolvedValue(task);
+
+ const res = await POST(makeReq(), makeCtx());
+ const body = await res.json();
+
+ expect(body.active_task.id).toBe("t1");
+ expect(body.task_messages).toEqual([]);
+ expect(mockListTaskMessages).not.toHaveBeenCalled();
+ });
+
+ it("sets has_more_messages true when messages reach limit", async () => {
+ const msgs = Array.from({ length: 20 }, (_, i) => ({
+ id: `m${i}`,
+ conversationId: "c1",
+ role: "user",
+ content: `msg ${i}`,
+ taskId: null,
+ createdAt: "2024-01-01T00:00:00.000Z",
+ }));
+
+ setupDefaults();
+ mockListMessages.mockResolvedValue(msgs);
+
+ const res = await POST(makeReq(), makeCtx());
+ const body = await res.json();
+
+ expect(body.has_more_messages).toBe(true);
+ expect(body.messages).toHaveLength(20);
+ });
+
+ it("returns empty state for new conversation", async () => {
+ setupDefaults();
+
+ const res = await POST(makeReq(), makeCtx());
+ const body = await res.json();
+
+ expect(res.status).toBe(200);
+ expect(body.messages).toEqual([]);
+ expect(body.artifacts).toEqual([]);
+ expect(body.buffered_messages).toEqual([]);
+ expect(body.active_task).toBeNull();
+ expect(body.has_more_messages).toBe(false);
+ });
+});
diff --git a/src/web/src/app/api/agents/[id]/chat-init/route.ts b/src/web/src/app/api/agents/[id]/chat-init/route.ts
new file mode 100644
index 000000000..546baa075
--- /dev/null
+++ b/src/web/src/app/api/agents/[id]/chat-init/route.ts
@@ -0,0 +1,87 @@
+import { getCloudflareContext } from "@opennextjs/cloudflare";
+import { queries } from "@alook/shared";
+import { getDb } from "@/lib/db";
+import { withAuth } from "@/lib/middleware/auth";
+import { withWorkspaceMember } from "@/lib/middleware/workspace";
+import { writeJSON, writeError } from "@/lib/middleware/helpers";
+import {
+ conversationToResponse,
+ messageToResponse,
+ taskToResponse,
+ taskMessageToResponse,
+} from "@/lib/api/responses";
+
+const MESSAGE_LIMIT = 20;
+
+export const POST = withAuth(async (req, ctx) => {
+ const ws = await withWorkspaceMember(req, ctx);
+ if (ws instanceof Response) return ws;
+
+ const { env } = getCloudflareContext();
+ const db = getDb((env as Env).DB);
+
+ const id = ctx.params?.id;
+ if (!id) {
+ return writeError("agent id is required", 400);
+ }
+
+ const agent = await queries.agent.getAgent(db, id, ws.workspaceId);
+ if (!agent) {
+ return writeError("agent not found", 404);
+ }
+
+ const conversation = await queries.conversation.getOrCreateAgentConversation(
+ db,
+ ws.workspaceId,
+ ctx.userId,
+ id,
+ );
+
+ const convId = conversation.id;
+
+ const [messagesResult, artifactsResult, bufferedResult, activeTaskResult] =
+ await Promise.allSettled([
+ queries.message.listMessages(db, convId, { limit: MESSAGE_LIMIT }),
+ queries.artifact.listArtifactsByConversation(db, convId, ws.workspaceId),
+ queries.message.listBufferedMessages(db, convId),
+ queries.task.getActiveTaskByConversation(db, convId, ws.workspaceId),
+ ]);
+
+ const messages =
+ messagesResult.status === "fulfilled" ? messagesResult.value : [];
+ const artifacts =
+ artifactsResult.status === "fulfilled" ? artifactsResult.value : [];
+ const buffered =
+ bufferedResult.status === "fulfilled" ? bufferedResult.value : [];
+ const activeTask =
+ activeTaskResult.status === "fulfilled"
+ ? activeTaskResult.value
+ : null;
+
+ let taskMessages: unknown[] = [];
+ if (
+ activeTask &&
+ activeTask.status !== "completed" &&
+ activeTask.status !== "failed"
+ ) {
+ try {
+ const tmsgs = await queries.taskMessage.listTaskMessages(
+ db,
+ activeTask.id,
+ );
+ taskMessages = tmsgs.map(taskMessageToResponse);
+ } catch {
+ // non-critical — frontend will recover via polling
+ }
+ }
+
+ return writeJSON({
+ conversation: conversationToResponse(conversation),
+ messages: messages.map(messageToResponse),
+ artifacts: artifacts.map(queries.artifact.artifactToResponse),
+ buffered_messages: buffered.map(messageToResponse),
+ active_task: activeTask ? taskToResponse(activeTask) : null,
+ task_messages: taskMessages,
+ has_more_messages: messages.length >= MESSAGE_LIMIT,
+ });
+});
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 fa2255764..1f91c03e8 100644
--- a/src/web/src/components/agent-chat/agent-chat-view.tsx
+++ b/src/web/src/components/agent-chat/agent-chat-view.tsx
@@ -6,12 +6,12 @@ import { useWorkspace } from "@/contexts/workspace-context";
import { Button } from "@/components/ui/button";
import { TaskStream } from "@/components/task-stream";
import {
+ chatInit,
getOrCreateAgentConversation,
listMessages,
sendMessage,
getTask,
getTaskMessages,
- getActiveTask,
deleteConversation,
listArtifacts,
listBufferedMessages,
@@ -233,42 +233,24 @@ export function AgentChatView() {
}, 50);
}, []);
- // Resolve conversation (get or create) then load messages + recover active task
useEffect(() => {
async function load() {
try {
- const conv = await getOrCreateAgentConversation(agentId, workspaceId);
- setConversation(conv);
- const [msgs, arts, buffered] = await Promise.allSettled([
- listMessages(conv.id, workspaceId, { limit: MESSAGE_LIMIT }),
- listArtifacts(conv.id, workspaceId),
- listBufferedMessages(conv.id, workspaceId),
- ]);
-
- if (msgs.status === "fulfilled") {
- setMessages(msgs.value);
- setHasMore(msgs.value.length >= MESSAGE_LIMIT);
- } else {
- toast.error("Failed to load messages");
- }
- if (arts.status === "fulfilled") {
- setArtifacts(arts.value);
- }
- if (buffered.status === "fulfilled") {
- setBufferedMessages(buffered.value);
- }
-
- // Recover active task (e.g. after page refresh)
- const task = await getActiveTask(conv.id, workspaceId);
- if (task) {
- setActiveTask(task);
- const tmsgs = await getTaskMessages(task.id, workspaceId);
- if (tmsgs.length > 0) {
- setTaskMessages(tmsgs);
- lastSeqRef.current = Math.max(...tmsgs.map((m) => m.seq));
+ const data = await chatInit(agentId, workspaceId);
+ setConversation(data.conversation);
+ setMessages(data.messages);
+ setHasMore(data.has_more_messages);
+ setArtifacts(data.artifacts);
+ setBufferedMessages(data.buffered_messages);
+
+ if (data.active_task) {
+ setActiveTask(data.active_task);
+ if (data.task_messages.length > 0) {
+ setTaskMessages(data.task_messages);
+ lastSeqRef.current = Math.max(...data.task_messages.map((m) => m.seq));
}
- if (task.status !== "completed" && task.status !== "failed") {
- startPollingRef.current(task.id, conv.id, lastSeqRef.current);
+ if (data.active_task.status !== "completed" && data.active_task.status !== "failed") {
+ startPollingRef.current(data.active_task.id, data.conversation.id, lastSeqRef.current);
}
}
} catch {
diff --git a/src/web/src/lib/api.ts b/src/web/src/lib/api.ts
index 71bf1a8d5..53b654e6d 100644
--- a/src/web/src/lib/api.ts
+++ b/src/web/src/lib/api.ts
@@ -164,6 +164,21 @@ export const getOrCreateAgentConversation = (agentId: string, workspaceId: strin
method: "POST",
});
+export interface ChatInitResponse {
+ conversation: Conversation;
+ messages: Message[];
+ artifacts: Artifact[];
+ buffered_messages: Message[];
+ active_task: TaskApi | null;
+ task_messages: TaskMessage[];
+ has_more_messages: boolean;
+}
+
+export const chatInit = (agentId: string, workspaceId: string) =>
+ apiFetch<ChatInitResponse>(`/api/agents/${agentId}/chat-init${wsQuery(workspaceId)}`, {
+ method: "POST",
+ });
+
export const deleteConversation = (id: string, workspaceId: string) =>
apiFetch<void>(`/api/conversations/${id}${wsQuery(workspaceId)}`, { method: "DELETE" });