feat: move artist copy flow server-side

app/api/chat/route.ts

@@ -2,6 +2,7 @@ import type { NextRequest } from "next/server";
 import { NextResponse } from "next/server";
 import { getCorsHeaders } from "@/lib/networking/getCorsHeaders";
 import { handleChatStream } from "@/lib/chat/handleChatStream";
+import { handleCreateArtistRedirect } from "@/lib/chat/handleCreateArtistRedirect";
 
 /**
  * OPTIONS handler for CORS preflight requests.
@@ -37,5 +38,16 @@ export async function OPTIONS() {
  * @returns A streaming response or error
  */
 export async function POST(request: NextRequest): Promise<Response> {
-  return handleChatStream(request);
+  return handleChatStream(request, async ({ body, responseMessages, writer }) => {
+    const redirectPath = await handleCreateArtistRedirect(body, responseMessages);
+    if (!redirectPath) {
+      return;
+    }
+
+    writer.write({
+      type: "data-redirect",
+      data: { path: redirectPath },
+      transient: true,
+    });
+  });
 }

lib/chat/__tests__/handleChatCompletion.test.ts

@@ -317,5 +317,36 @@ describe("handleChatCompletion", () => {
         }),
       );
     });
+
+    it("returns redirect path after creating and copying the final artist room", async () => {
+      const body = createMockBody();
+      const responseMessages: UIMessage[] = [
+        {
+          id: "resp-1",
+          role: "assistant",
+          parts: [
+            {
+              type: "tool-create_new_artist",
+              toolCallId: "tool-1",
+              state: "output-available",
+              input: {},
+              output: {
+                artist: {
+                  account_id: "artist-123",
+                  name: "Test Artist",
+                },
+                artistAccountId: "artist-123",
+                message: "ok",
+              },
+            } as any,
+          ],
+          createdAt: new Date(),
+        },
+      ];
+
+      await handleChatCompletion(body, responseMessages);
+
+      expect(mockHandleSendEmailToolOutputs).toHaveBeenCalledWith(responseMessages);
+    });
   });
 });

lib/chat/__tests__/handleChatStream.test.ts

@@ -5,6 +5,8 @@ import { getApiKeyAccountId } from "@/lib/auth/getApiKeyAccountId";
 import { validateOverrideAccountId } from "@/lib/accounts/validateOverrideAccountId";
 import { setupChatRequest } from "@/lib/chat/setupChatRequest";
 import { setupConversation } from "@/lib/chat/setupConversation";
+import { handleChatCompletion } from "@/lib/chat/handleChatCompletion";
+import { handleCreateArtistRedirect } from "@/lib/chat/handleCreateArtistRedirect";
 import { createUIMessageStream, createUIMessageStreamResponse } from "ai";
 import { handleChatStream } from "../handleChatStream";
 
@@ -54,6 +56,10 @@ vi.mock("@/lib/chat/handleChatCompletion", () => ({
   handleChatCompletion: vi.fn(),
 }));
 
+vi.mock("@/lib/chat/handleCreateArtistRedirect", () => ({
+  handleCreateArtistRedirect: vi.fn(),
+}));
+
 vi.mock("@/lib/credits/handleChatCredits", () => ({
   handleChatCredits: vi.fn(),
 }));
@@ -71,6 +77,8 @@ const mockGetApiKeyAccountId = vi.mocked(getApiKeyAccountId);
 const mockValidateOverrideAccountId = vi.mocked(validateOverrideAccountId);
 const mockSetupConversation = vi.mocked(setupConversation);
 const mockSetupChatRequest = vi.mocked(setupChatRequest);
+const mockHandleChatCompletion = vi.mocked(handleChatCompletion);
+const mockHandleCreateArtistRedirect = vi.mocked(handleCreateArtistRedirect);
 const mockCreateUIMessageStream = vi.mocked(createUIMessageStream);
 const mockCreateUIMessageStreamResponse = vi.mocked(createUIMessageStreamResponse);
 
@@ -99,6 +107,8 @@ describe("handleChatStream", () => {
       roomId: roomId || "mock-room-id",
       memoryId: "mock-memory-id",
     }));
+    mockHandleChatCompletion.mockResolvedValue();
+    mockHandleCreateArtistRedirect.mockResolvedValue(undefined);
   });
 
   afterEach(() => {
@@ -247,6 +257,79 @@ describe("handleChatStream", () => {
         }),
       );
     });
+
+    it("uses sendFinish false and emits redirect data after completion", async () => {
+      mockGetApiKeyAccountId.mockResolvedValue("account-123");
+      const toUIMessageStream = vi.fn().mockReturnValue(new ReadableStream());
+      const mockAgent = {
+        stream: vi.fn().mockResolvedValue({
+          toUIMessageStream,
+          usage: Promise.resolve({ inputTokens: 100, outputTokens: 50 }),
+        }),
+        tools: {},
+      };
+
+      mockSetupChatRequest.mockResolvedValue({
+        agent: mockAgent,
+        messages: [],
+      } as any);
+
+      const mockStream = new ReadableStream();
+      mockCreateUIMessageStream.mockReturnValue(mockStream);
+      mockCreateUIMessageStreamResponse.mockReturnValue(new Response(mockStream));
+
+      const request = createMockRequest({ prompt: "Hello" }, { "x-api-key": "valid-key" });
+
+      await handleChatStream(request as any, async ({ body, responseMessages, writer }) => {
+        const redirectPath = await handleCreateArtistRedirect(body, responseMessages);
+        if (!redirectPath) {
+          return;
+        }
+
+        writer.write({
+          type: "data-redirect",
+          data: { path: redirectPath },
+          transient: true,
+        });
+      });
+
+      mockHandleCreateArtistRedirect.mockResolvedValue("/chat/new-room-123");
+
+      const execute = mockCreateUIMessageStream.mock.calls[0][0].execute;
+      const writer = {
+        merge: vi.fn(),
+        write: vi.fn(),
+        onError: undefined,
+      };
+
+      await execute({ writer } as any);
+
+      expect(toUIMessageStream).toHaveBeenCalledWith(
+        expect.objectContaining({
+          sendFinish: false,
+          onFinish: expect.any(Function),
+        }),
+      );
+
+      const onFinish = toUIMessageStream.mock.calls[0][0].onFinish;
+      await onFinish({
+        isAborted: false,
+        finishReason: "stop",
+        messages: [{ id: "resp-1", role: "assistant", parts: [] }],
+        responseMessage: { id: "resp-1", role: "assistant", parts: [] },
+        isContinuation: false,
+      });
+
+      expect(writer.write).toHaveBeenCalledWith({
+        type: "data-redirect",
+        data: { path: "/chat/new-room-123" },
+        transient: true,
+      });
+      expect(writer.write).toHaveBeenCalledWith({
+        type: "finish",
+        finishReason: "stop",
+      });
+    });
   });
 
   describe("error handling", () => {

lib/chat/__tests__/handleCreateArtistRedirect.test.ts

@@ -0,0 +1,86 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { UIMessage } from "ai";
+import { copyRoom } from "@/lib/rooms/copyRoom";
+import { copyChatMessages } from "@/lib/chats/copyChatMessages";
+import { handleCreateArtistRedirect } from "../handleCreateArtistRedirect";
+
+vi.mock("@/lib/rooms/copyRoom", () => ({
+  copyRoom: vi.fn(),
+}));
+
+vi.mock("@/lib/chats/copyChatMessages", () => ({
+  copyChatMessages: vi.fn(),
+}));
+
+const mockCopyRoom = vi.mocked(copyRoom);
+const mockCopyChatMessages = vi.mocked(copyChatMessages);
+
+describe("handleCreateArtistRedirect", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("returns redirect path after creating and copying the final artist room", async () => {
+    mockCopyRoom.mockResolvedValue("new-room-123");
+    mockCopyChatMessages.mockResolvedValue({
+      status: "success",
+      copiedCount: 1,
+      clearedExisting: true,
+    });
+
+    const responseMessages: UIMessage[] = [
+      {
+        id: "resp-1",
+        role: "assistant",
+        parts: [
+          {
+            type: "tool-create_new_artist",
+            toolCallId: "tool-1",
+            state: "output-available",
+            input: {},
+            output: {
+              artist: {
+                account_id: "artist-123",
+                name: "Test Artist",
+              },
+              artistAccountId: "artist-123",
+              message: "ok",
+            },
+          } as any,
+        ],
+        createdAt: new Date(),
+      },
+    ];
+
+    const result = await handleCreateArtistRedirect(
+      {
+        accountId: "account-123",
+        messages: [],
+        roomId: "room-456",
+      } as any,
+      responseMessages,
+    );
+
+    expect(mockCopyRoom).toHaveBeenCalledWith("room-456", "artist-123");
+    expect(mockCopyChatMessages).toHaveBeenCalledWith({
+      sourceChatId: "room-456",
+      targetChatId: "new-room-123",
+      clearExisting: true,
+    });
+    expect(result).toBe("/chat/new-room-123");
+  });
+
+  it("returns undefined when no create artist result exists", async () => {
+    const result = await handleCreateArtistRedirect(
+      {
+        accountId: "account-123",
+        messages: [],
+        roomId: "room-456",
+      } as any,
+      [{ id: "resp-1", role: "assistant", parts: [], createdAt: new Date() }],
+    );
+
+    expect(result).toBeUndefined();
+    expect(mockCopyRoom).not.toHaveBeenCalled();
+  });
+});

lib/chat/handleChatStream.ts

@@ -7,6 +7,16 @@ import { setupChatRequest } from "./setupChatRequest";
 import { getCorsHeaders } from "@/lib/networking/getCorsHeaders";
 import generateUUID from "@/lib/uuid/generateUUID";
 import { DEFAULT_MODEL } from "@/lib/const";
+import type { ChatRequestBody } from "./validateChatRequest";
+import type { UIMessage } from "ai";
+
+type ChatStreamFinishHandler = (params: {
+  body: ChatRequestBody;
+  responseMessages: UIMessage[];
+  writer: {
+    write: (chunk: unknown) => void;
+  };
+}) => Promise<void>;
 
 /**
  * Handles a streaming chat request.
@@ -19,7 +29,10 @@ import { DEFAULT_MODEL } from "@/lib/const";
  * @param request - The incoming NextRequest
  * @returns A streaming response or error NextResponse
  */
-export async function handleChatStream(request: NextRequest): Promise<Response> {
+export async function handleChatStream(
+  request: NextRequest,
+  onFinish?: ChatStreamFinishHandler,
+): Promise<Response> {
   const validatedBodyOrError = await validateChatRequest(request);
   if (validatedBodyOrError instanceof NextResponse) {
     return validatedBodyOrError;
@@ -38,23 +51,35 @@ export async function handleChatStream(request: NextRequest): Promise<Response>
       execute: async options => {
         const { writer } = options;
         streamResult = await agent.stream(chatConfig);
-        writer.merge(streamResult.toUIMessageStream());
-      },
-      onFinish: async event => {
-        if (event.isAborted) {
-          return;
-        }
-        const assistantMessages = event.messages.filter(message => message.role === "assistant");
-        const responseMessages =
-          assistantMessages.length > 0 ? assistantMessages : [event.responseMessage];
-        await handleChatCompletion(body, responseMessages);
-        if (streamResult) {
-          await handleChatCredits({
-            usage: await streamResult.usage,
-            model: body.model ?? DEFAULT_MODEL,
-            accountId: body.accountId,
-          });
-        }
+        writer.merge(
+          streamResult.toUIMessageStream({
+            sendFinish: false,
+            onFinish: async event => {
+              if (event.isAborted) {
+                return;
+              }
+
+              const assistantMessages = event.messages.filter(
+                message => message.role === "assistant",
+              );
+              const responseMessages =
+                assistantMessages.length > 0 ? assistantMessages : [event.responseMessage];
+              await handleChatCompletion(body, responseMessages);
+              await onFinish?.({ body, responseMessages, writer });
+
+              writer.write({
+                type: "finish",
+                finishReason: event.finishReason,
+              });
+
+              await handleChatCredits({
+                usage: await streamResult!.usage,
+                model: body.model ?? DEFAULT_MODEL,
+                accountId: body.accountId,
+              });
+            },
+          }),
+        );
       },
       onError: e => {
         console.error("/api/chat onError:", e);