feat(lightspeed): notebook chat

workspaces/lightspeed/.changeset/bright-notebooks-stream.md

@@ -0,0 +1,11 @@
+---
+'@red-hat-developer-hub/backstage-plugin-lightspeed': minor
+'@red-hat-developer-hub/backstage-plugin-lightspeed-backend': patch
+---
+
+Add notebook chat with streaming support, document management, and UI improvements.
+
+- Backend: add SSE transform to normalize Responses API format to legacy streaming format so notebook chat streams token-by-token like the chat tab.
+- Frontend: add notebook chat view with conversation messages, document sidebar with per-document delete, and topic summary display.
+- Fix stale document list when re-opening a notebook by setting query staleTime to 0.
+- Hide model selector on the Notebooks tab while keeping the settings ellipsis menu visible.

workspaces/lightspeed/plugins/lightspeed-backend/src/service/notebooks/notebooksRouters.ts

@@ -26,7 +26,7 @@ import express, { Router } from 'express';
 
 import { lightspeedNotebooksUsePermission } from '@red-hat-developer-hub/backstage-plugin-lightspeed-common';
 
-import { Readable } from 'stream';
+import { Readable, Transform } from 'stream';
 
 import {
   DEFAULT_LIGHTSPEED_SERVICE_PORT,
@@ -153,52 +153,115 @@ export async function createNotebooksRouter(
       }
     };
 
-  const createConversationIdCaptureTransform = (
+  /**
+   * Transforms Responses API SSE (event:/data: lines) into the legacy
+   * streaming format that the frontend useConversationMessages hook expects:
+   *   data: {"event": "<type>", "data": {...}}\n\n
+   *
+   * Also captures the conversation_id from the first response.created event
+   * and persists it on the session when it is new.
+   */
+  const createResponsesApiTransform = (
     session: any,
     sessionId: string,
     userId: string,
   ) => {
-    const { Transform } = require('stream');
-    let captured = false;
     let buffer = '';
+    let conversationCaptured = !!session.metadata?.conversation_id;
 
     return new Transform({
       transform(chunk: any, _encoding: any, callback: any) {
-        this.push(chunk);
+        buffer += chunk.toString();
 
-        if (!captured) {
-          buffer += chunk.toString();
-          const lines = buffer.split('\n');
-          buffer = buffer.endsWith('\n') ? '' : lines.pop() || '';
+        const blocks = buffer.split('\n\n');
+        buffer = blocks.pop()!;
+
+        for (const block of blocks) {
+          if (!block.trim()) continue;
+
+          const lines = block.split('\n');
+          let eventType = '';
+          let dataLine = '';
+
+          for (const line of lines) {
+            if (line.startsWith('event: ')) {
+              eventType = line.slice(7).trim();
+            } else if (line.startsWith('data: ')) {
+              dataLine = line.slice(6).trim();
+            }
+          }
+
+          if (dataLine === '[DONE]') {
+            this.push('data: [DONE]\n\n');
+            continue;
+          }
+
+          if (!dataLine) continue;
+
+          let parsed: any;
+          try {
+            parsed = JSON.parse(dataLine);
+          } catch {
+            continue;
+          }
+
+          if (eventType === 'response.created') {
+            const convId = parsed?.response?.conversation;
+            const requestId = parsed?.response?.id;
+
+            if (convId && !conversationCaptured) {
+              conversationCaptured = true;
+              logger.info(`Captured conversation ID: ${convId}`);
+              sessionService
+                .updateSession(sessionId, userId, undefined, undefined, {
+                  ...session.metadata,
+                  conversation_id: convId,
+                })
+                .catch((err: any) =>
+                  logger.error(`Failed to update session: ${err}`),
+                );
+            }
+
+            const legacy = {
+              event: 'start',
+              data: { conversation_id: convId, request_id: requestId },
+            };
+            this.push(`data: ${JSON.stringify(legacy)}\n\n`);
+          } else if (eventType === 'response.output_text.delta') {
+            const legacy = {
+              event: 'token',
+              data: { token: parsed?.delta ?? '' },
+            };
+            this.push(`data: ${JSON.stringify(legacy)}\n\n`);
+          } else if (eventType === 'response.completed') {
+            const usage = parsed?.response?.usage;
+            const legacy = {
+              event: 'end',
+              data: {
+                referenced_documents: [],
+                input_tokens: usage?.input_tokens,
+                output_tokens: usage?.output_tokens,
+              },
+            };
+            this.push(`data: ${JSON.stringify(legacy)}\n\n`);
+          }
+        }
 
+        callback();
+      },
+
+      flush(callback: any) {
+        if (buffer.trim()) {
+          const lines = buffer.split('\n');
+          let dataLine = '';
           for (const line of lines) {
-            if (
-              line.startsWith('data: ') &&
-              line.slice(6).trim() !== '[DONE]'
-            ) {
-              try {
-                const conversationId = JSON.parse(line.slice(6))?.response
-                  ?.conversation;
-                if (conversationId) {
-                  captured = true;
-                  buffer = '';
-                  logger.info(`Captured conversation ID: ${conversationId}`);
-
-                  sessionService
-                    .updateSession(sessionId, userId, undefined, undefined, {
-                      ...session.metadata,
-                      conversation_id: conversationId,
-                    })
-                    .catch((err: any) =>
-                      logger.error(`Failed to update session: ${err}`),
-                    );
-                  break;
-                }
-              } catch {
-                // Ignore parse errors for non-JSON SSE markers
-              }
+            if (line.startsWith('data: ')) {
+              dataLine = line.slice(6).trim();
             }
           }
+          if (dataLine === '[DONE]') {
+            this.push('data: [DONE]\n\n');
+          }
         }
         callback();
       },
@@ -445,16 +508,9 @@ export async function createNotebooksRouter(
 
         if (response.body) {
           const body = Readable.fromWeb(response.body as any);
-          const stream = conversationId
-            ? body
-            : body.pipe(
-                createConversationIdCaptureTransform(
-                  session,
-                  sessionId,
-                  userId,
-                ),
-              );
-          stream.pipe(res);
+          body
+            .pipe(createResponsesApiTransform(session, sessionId, userId))
+            .pipe(res);
         }
         break;
       }

workspaces/lightspeed/plugins/lightspeed/report-alpha.api.md

@@ -247,6 +247,7 @@ export const lightspeedTranslationRef: TranslationRef<
     readonly 'notebook.overwrite.modal.title': string;
     readonly 'notebook.overwrite.modal.description': string;
     readonly 'notebook.overwrite.modal.action': string;
+    readonly 'notebook.document.delete': string;
     readonly 'conversation.delete.confirm.title': string;
     readonly 'conversation.delete.confirm.message': string;
     readonly 'conversation.delete.confirm.action': string;

workspaces/lightspeed/plugins/lightspeed/src/api/NotebooksApiClient.ts

@@ -205,4 +205,37 @@ export class NotebooksApiClient implements NotebooksAPI {
       `${baseUrl}/v1/sessions/${encodeURIComponent(sessionId)}/documents/${encodeURIComponent(documentId)}/status`,
     );
   }
+
+  async querySession(
+    sessionId: string,
+    query: string,
+  ): Promise<ReadableStreamDefaultReader<Uint8Array>> {
+    const baseUrl = await this.getBaseUrl();
+    const response = await this.fetchApi.fetch(
+      `${baseUrl}/v1/sessions/${encodeURIComponent(sessionId)}/query`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ query }),
+      },
+    );
+
+    if (!response.body) {
+      throw new Error('Readable stream is not supported or there is no body.');
+    }
+
+    if (!response.ok) {
+      const reader = response.body.getReader();
+      const { done, value } = await reader.read();
+      const text = done ? '' : new TextDecoder('utf-8').decode(value);
+      const errorMessage = JSON.parse(text);
+      if (errorMessage?.error) {
+        throw new Error(
+          `failed to query notebook session: ${errorMessage.error}`,
+        );
+      }
+    }
+
+    return response.body.getReader();
+  }
 }

workspaces/lightspeed/plugins/lightspeed/src/api/notebooksApi.ts

@@ -48,6 +48,10 @@ export type NotebooksAPI = {
     sessionId: string,
     documentId: string,
   ) => Promise<DocumentStatus>;
+  querySession: (
+    sessionId: string,
+    query: string,
+  ) => Promise<ReadableStreamDefaultReader<Uint8Array>>;
 };
 
 /**

workspaces/lightspeed/plugins/lightspeed/src/components/LightSpeedChat.tsx

@@ -486,7 +486,7 @@ export const LightspeedChat = ({
   const notebooksPermissionResolved =
     !notebooksPermissionLoading && hasNotebooksAccess;
   const { data: notebooks = [], refetch: refetchNotebooks } =
-    useNotebookSessions(activeTab === 1 && notebooksPermissionResolved);
+    useNotebookSessions(notebooksPermissionResolved);
   const hasNotebooks = notebooks.length > 0;
   const [openNotebookMenuId, setOpenNotebookMenuId] = useState<string | null>(
     null,
@@ -731,6 +731,7 @@ export const LightspeedChat = ({
       avatar,
       onComplete,
       onStart,
+      undefined,
       onRequestIdReady,
     );
 
@@ -860,16 +861,40 @@ export const LightspeedChat = ({
     ],
   );
 
+  const notebookConversationIds = useMemo(
+    () =>
+      new Set(
+        notebooks
+          .map(n => n.metadata?.conversation_id)
+          .filter((id): id is string => !!id),
+      ),
+    [notebooks],
+  );
+
+  const chatOnlyConversations = useMemo(
+    () =>
+      conversations.filter(
+        c => !notebookConversationIds.has(c.conversation_id),
+      ),
+    [conversations, notebookConversationIds],
+  );
+
   const categorizedMessages = useMemo(
     () =>
       getCategorizeMessages(
-        conversations,
+        chatOnlyConversations,
         pinnedChats,
         additionalMessageProps,
         t,
         selectedSort,
       ),
-    [additionalMessageProps, conversations, pinnedChats, t, selectedSort],
+    [
+      additionalMessageProps,
+      chatOnlyConversations,
+      pinnedChats,
+      t,
+      selectedSort,
+    ],
   );
 
   const filterConversations = useCallback(
@@ -1517,6 +1542,7 @@ export const LightspeedChat = ({
             models={models}
             isPinningChatsEnabled={isPinningChatsEnabled}
             isModelSelectorDisabled={isSendButtonDisabled}
+            hideModelSelector={showNotebooksPanel}
             setDisplayMode={setDisplayMode}
             displayMode={displayMode}
             onPinnedChatsToggle={handlePinningChatsToggle}
@@ -1617,6 +1643,18 @@ export const LightspeedChat = ({
               sessionId={activeNotebook.session_id}
               notebookName={activeNotebook.name}
               documents={notebookDocuments}
+              metadata={activeNotebook.metadata}
+              topicSummary={
+                conversations.find(
+                  c =>
+                    c.conversation_id ===
+                    activeNotebook.metadata?.conversation_id,
+                )?.topic_summary ?? undefined
+              }
+              userName={userName}
+              avatar={avatar}
+              profileLoading={profileLoading}
+              topicRestrictionEnabled={topicRestrictionEnabled}
               onClose={handleCloseNotebook}
             />
           )}