fix(web): Fix issue with blocking chat api

CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+- Fixed issue where chat threads created via the `/api/chat/blocking` endpoint would not have any messages when called without authentication. [#907](https://github.com/sourcebot-dev/sourcebot/pull/907)
+
+### Changed
+- Added `chatId` to all chat related posthog events. [#907](https://github.com/sourcebot-dev/sourcebot/pull/907)
+
 ## [4.11.2] - 2026-02-18
 
 ### Fixed

packages/web/src/app/api/(server)/chat/blocking/route.ts

@@ -1,5 +1,5 @@
 import { sew } from "@/actions";
-import { _getConfiguredLanguageModelsFull, _getAISDKLanguageModelAndOptions, updateChatMessages, generateAndUpdateChatNameFromMessage } from "@/features/chat/actions";
+import { _getConfiguredLanguageModelsFull, _getAISDKLanguageModelAndOptions, _updateChatMessages, generateAndUpdateChatNameFromMessage, _generateChatNameFromMessage } from "@/features/chat/actions";
 import { LanguageModelInfo, languageModelInfoSchema, SBChatMessage, SearchScope } from "@/features/chat/types";
 import { convertLLMOutputToPortableMarkdown, getAnswerPartFromAssistantMessage, getLanguageModelKey } from "@/features/chat/utils";
 import { ErrorCode } from "@/lib/errorCodes";
@@ -15,6 +15,7 @@ import { z } from "zod";
 import { createMessageStream } from "../route";
 import { InferUIMessageChunk, UITools, UIDataTypes, UIMessage } from "ai";
 import { apiHandler } from "@/lib/apiHandler";
+import { captureEvent } from "@/lib/posthog";
 
 const logger = createLogger('chat-blocking-api');
 
@@ -115,6 +116,11 @@ export const POST = apiHandler(async (request: NextRequest) => {
                 },
             });
 
+            await captureEvent('wa_chat_thread_created', {
+                chatId: chat.id,
+                isAnonymous: !user,
+            });
+
             // Run the agent to completion
             logger.debug(`Starting blocking agent for chat ${chat.id}`, {
                 chatId: chat.id,
@@ -155,7 +161,13 @@ export const POST = apiHandler(async (request: NextRequest) => {
             // We'll capture the final messages and usage from the stream
             let finalMessages: SBChatMessage[] = [];
 
+            await captureEvent('wa_chat_message_sent', {
+                chatId: chat.id,
+                messageCount: 1,
+            });
+
             const stream = await createMessageStream({
+                chatId: chat.id,
                 messages: [userMessage],
                 selectedSearchScopes,
                 model,
@@ -180,21 +192,28 @@ export const POST = apiHandler(async (request: NextRequest) => {
                 },
             })
 
-            await Promise.all([
+            const [_, name] = await Promise.all([
                 // Consume the stream fully to trigger onFinish
                 blockStreamUntilFinish(stream),
                 // Generate and update the chat name
-                generateAndUpdateChatNameFromMessage({
-                    chatId: chat.id,
-                    languageModelId: languageModelConfig.model,
+                _generateChatNameFromMessage({
                     message: query,
+                    languageModelConfig,
                 })
             ]);
 
             // Persist the messages to the chat
-            await updateChatMessages({
-                chatId: chat.id,
-                messages: finalMessages,
+            await _updateChatMessages({ chatId: chat.id, messages: finalMessages, prisma });
+
+            // Update the chat name
+            await prisma.chat.update({
+                where: {
+                    id: chat.id,
+                    orgId: org.id,
+                },
+                data: {
+                    name: name,
+                },
             });
 
             // Extract the answer text from the assistant message

packages/web/src/app/api/(server)/chat/route.ts

@@ -1,5 +1,5 @@
 import { sew } from "@/actions";
-import { _getConfiguredLanguageModelsFull, _getAISDKLanguageModelAndOptions, updateChatMessages, _isOwnerOfChat } from "@/features/chat/actions";
+import { _getConfiguredLanguageModelsFull, _getAISDKLanguageModelAndOptions, _updateChatMessages, _isOwnerOfChat } from "@/features/chat/actions";
 import { createAgentStream } from "@/features/chat/agent";
 import { additionalChatRequestParamsSchema, LanguageModelInfo, SBChatMessage, SearchScope } from "@/features/chat/types";
 import { getAnswerPartFromAssistantMessage, getLanguageModelKey } from "@/features/chat/utils";
@@ -12,6 +12,7 @@ import { LanguageModelV2 as AISDKLanguageModelV2 } from "@ai-sdk/provider";
 import * as Sentry from "@sentry/nextjs";
 import { PrismaClient } from "@sourcebot/db";
 import { createLogger } from "@sourcebot/shared";
+import { captureEvent } from "@/lib/posthog";
 import {
     createUIMessageStream,
     createUIMessageStreamResponse,
@@ -88,7 +89,13 @@ export const POST = apiHandler(async (req: NextRequest) => {
 
             const { model, providerOptions } = await _getAISDKLanguageModelAndOptions(languageModelConfig);
 
+            await captureEvent('wa_chat_message_sent', {
+                chatId: id,
+                messageCount: messages.length,
+            });
+
             const stream = await createMessageStream({
+                chatId: id,
                 messages,
                 selectedSearchScopes,
                 model,
@@ -97,10 +104,7 @@ export const POST = apiHandler(async (req: NextRequest) => {
                 orgId: org.id,
                 prisma,
                 onFinish: async ({ messages }) => {
-                    await updateChatMessages({
-                        chatId: id,
-                        messages
-                    });
+                    await _updateChatMessages({ chatId: id, messages, prisma });
                 },
                 onError: (error: unknown) => {
                     logger.error(error);
@@ -146,6 +150,7 @@ const mergeStreamAsync = async (stream: StreamTextResult<any, any>, writer: UIMe
 }
 
 interface CreateMessageStreamResponseProps {
+    chatId: string;
     messages: SBChatMessage[];
     selectedSearchScopes: SearchScope[];
     model: AISDKLanguageModelV2;
@@ -158,6 +163,7 @@ interface CreateMessageStreamResponseProps {
 }
 
 export const createMessageStream = async ({
+    chatId,
     messages,
     selectedSearchScopes,
     model,
@@ -242,6 +248,7 @@ export const createMessageStream = async ({
                     });
                 },
                 traceId,
+                chatId,
             });
 
             await mergeStreamAsync(researchStream, writer, {

packages/web/src/features/chat/actions.ts

@@ -3,7 +3,7 @@
 import { sew } from "@/actions";
 import { getAuditService } from "@/ee/features/audit/factory";
 import { ErrorCode } from "@/lib/errorCodes";
-import { notFound, serviceErrorResponse } from "@/lib/serviceError";
+import { notFound, ServiceError } from "@/lib/serviceError";
 import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
 import { AnthropicProviderOptions, createAnthropic } from '@ai-sdk/anthropic';
 import { createAzure } from '@ai-sdk/azure';
@@ -62,7 +62,7 @@ export const _isOwnerOfChat = async (chat: Chat, user: User | undefined): Promis
 /**
  * Checks if a user has been explicitly shared access to a chat.
  */
-export const _hasSharedAccess = async ({prisma, chatId, userId}: {prisma: PrismaClient, chatId: string, userId: string | undefined}): Promise<boolean> => {
+export const _hasSharedAccess = async ({ prisma, chatId, userId }: { prisma: PrismaClient, chatId: string, userId: string | undefined }): Promise<boolean> => {
     if (!userId) {
         return false;
     }
@@ -79,6 +79,55 @@ export const _hasSharedAccess = async ({prisma, chatId, userId}: {prisma: Prisma
     return share !== null;
 };
 
+export const _updateChatMessages = async ({ chatId, messages, prisma }: { chatId: string, messages: SBChatMessage[], prisma: PrismaClient }) => {
+    await prisma.chat.update({
+        where: {
+            id: chatId,
+        },
+        data: {
+            messages: messages as unknown as Prisma.InputJsonValue,
+        },
+    });
+
+    if (env.DEBUG_WRITE_CHAT_MESSAGES_TO_FILE) {
+        const chatDir = path.join(env.DATA_CACHE_DIR, 'chats');
+        if (!fs.existsSync(chatDir)) {
+            fs.mkdirSync(chatDir, { recursive: true });
+        }
+
+        const chatFile = path.join(chatDir, `${chatId}.json`);
+        fs.writeFileSync(chatFile, JSON.stringify(messages, null, 2));
+    }
+};
+
+
+export const _generateChatNameFromMessage = async ({ message, languageModelConfig }: { message: string, languageModelConfig: LanguageModel }) => {
+    const { model } = await _getAISDKLanguageModelAndOptions(languageModelConfig);
+
+    const prompt = `Convert this question into a short topic title (max 50 characters). 
+
+Rules:
+- Do NOT include question words (what, where, how, why, when, which)
+- Do NOT end with a question mark
+- Capitalize the first letter of the title
+- Focus on the subject/topic being discussed
+- Make it sound like a file name or category
+
+Examples:
+"Where is the authentication code?" → "Authentication Code"
+"How to setup the database?" → "Database Setup"
+"What are the API endpoints?" → "API Endpoints"
+
+User question: ${message}`;
+
+    const result = await generateText({
+        model,
+        prompt,
+    });
+
+    return result.text;
+}
+
 export const createChat = async () => sew(() =>
     withOptionalAuthV2(async ({ org, user, prisma }) => {
         const isGuestUser = user === undefined;
@@ -112,6 +161,11 @@ export const createChat = async () => sew(() =>
             });
         }
 
+        await captureEvent('wa_chat_thread_created', {
+            chatId: chat.id,
+            isAnonymous: isGuestUser,
+        });
+
         return {
             id: chat.id,
             isAnonymous: isGuestUser,
@@ -133,7 +187,7 @@ export const getChatInfo = async ({ chatId }: { chatId: string }) => sew(() =>
         }
 
         const isOwner = await _isOwnerOfChat(chat, user);
-        const isSharedWithUser = await _hasSharedAccess({prisma, chatId, userId: user?.id});
+        const isSharedWithUser = await _hasSharedAccess({ prisma, chatId, userId: user?.id });
 
         // Private chats can only be viewed by the owner or users it's been shared with
         if (chat.visibility === ChatVisibility.PRIVATE && !isOwner && !isSharedWithUser) {
@@ -170,24 +224,7 @@ export const updateChatMessages = async ({ chatId, messages }: { chatId: string,
             return notFound();
         }
 
-        await prisma.chat.update({
-            where: {
-                id: chatId,
-            },
-            data: {
-                messages: messages as unknown as Prisma.InputJsonValue,
-            },
-        });
-
-        if (env.DEBUG_WRITE_CHAT_MESSAGES_TO_FILE) {
-            const chatDir = path.join(env.DATA_CACHE_DIR, 'chats');
-            if (!fs.existsSync(chatDir)) {
-                fs.mkdirSync(chatDir, { recursive: true });
-            }
-
-            const chatFile = path.join(chatDir, `${chatId}.json`);
-            fs.writeFileSync(chatFile, JSON.stringify(messages, null, 2));
-        }
+        await _updateChatMessages({ chatId, messages, prisma });
 
         return {
             success: true,
@@ -295,54 +332,52 @@ export const updateChatVisibility = async ({ chatId, visibility }: { chatId: str
 );
 
 export const generateAndUpdateChatNameFromMessage = async ({ chatId, languageModelId, message }: { chatId: string, languageModelId: string, message: string }) => sew(() =>
-    withOptionalAuthV2(async () => {
-            // From the language model ID, attempt to find the
-            // corresponding config in `config.json`.
-            const languageModelConfig =
-                (await _getConfiguredLanguageModelsFull())
-                    .find((model) => model.model === languageModelId);
-
-            if (!languageModelConfig) {
-                return serviceErrorResponse({
-                    statusCode: StatusCodes.BAD_REQUEST,
-                    errorCode: ErrorCode.INVALID_REQUEST_BODY,
-                    message: `Language model ${languageModelId} is not configured.`,
-                });
-            }
-
-            const { model } = await _getAISDKLanguageModelAndOptions(languageModelConfig);
-
-            const prompt = `Convert this question into a short topic title (max 50 characters). 
+    withOptionalAuthV2(async ({ prisma, user, org }) => {
+        const chat = await prisma.chat.findUnique({
+            where: {
+                id: chatId,
+                orgId: org.id,
+            },
+        });
 
-Rules:
-- Do NOT include question words (what, where, how, why, when, which)
-- Do NOT end with a question mark
-- Capitalize the first letter of the title
-- Focus on the subject/topic being discussed
-- Make it sound like a file name or category
+        if (!chat) {
+            return notFound();
+        }
 
-Examples:
-"Where is the authentication code?" → "Authentication Code"
-"How to setup the database?" → "Database Setup"
-"What are the API endpoints?" → "API Endpoints"
+        const isOwner = await _isOwnerOfChat(chat, user);
+        if (!isOwner) {
+            return notFound();
+        }
 
-User question: ${message}`;
+        const languageModelConfig =
+            (await _getConfiguredLanguageModelsFull())
+                .find((model) => model.model === languageModelId);
 
-            const result = await generateText({
-                model,
-                prompt,
-            });
+        if (!languageModelConfig) {
+            return {
+                statusCode: StatusCodes.BAD_REQUEST,
+                errorCode: ErrorCode.INVALID_REQUEST_BODY,
+                message: `Language model ${languageModelId} is not configured.`,
+            } satisfies ServiceError;
+        }
 
-            await updateChatName({
-                chatId,
-                name: result.text,
-            });
+        const name = await _generateChatNameFromMessage({ message, languageModelConfig });
 
-            return {
-                success: true,
-            }
+        await prisma.chat.update({
+            where: {
+                id: chatId,
+                orgId: org.id,
+            },
+            data: {
+                name: name,
+            },
         })
-    )
+
+        return {
+            success: true,
+        }
+    })
+)
 
 export const deleteChat = async ({ chatId }: { chatId: string }) => sew(() =>
     withAuthV2(async ({ org, user, prisma }) => {
@@ -436,7 +471,7 @@ export const duplicateChat = async ({ chatId, newName }: { chatId: string, newNa
 
         // Check if user can access the chat (owner, shared, or public)
         const isOwner = await _isOwnerOfChat(originalChat, user);
-        const isSharedWithUser = await _hasSharedAccess({prisma, chatId, userId: user?.id});
+        const isSharedWithUser = await _hasSharedAccess({ prisma, chatId, userId: user?.id });
         if (originalChat.visibility === ChatVisibility.PRIVATE && !isOwner && !isSharedWithUser) {
             return notFound();
         }
@@ -617,7 +652,7 @@ export const submitFeedback = async ({
         }
 
         // When a chat is private, only the creator or shared users can submit feedback.
-        const isSharedWithUser = await _hasSharedAccess({prisma, chatId, userId: user?.id});
+        const isSharedWithUser = await _hasSharedAccess({ prisma, chatId, userId: user?.id });
         if (chat.visibility === ChatVisibility.PRIVATE && chat.createdById !== user?.id && !isSharedWithUser) {
             return notFound();
         }