fix(lightspeed): update how tool call info is fetched after the query response update (#2607)

Author: debsmita1

workspaces/lightspeed/.changeset/clean-tomatoes-clean.md

@@ -0,0 +1,5 @@
+---
+'@red-hat-developer-hub/backstage-plugin-lightspeed': patch
+---
+
+update how tool call info is retrived

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

@@ -30,6 +30,7 @@ import { WrenchIcon } from '@patternfly/react-icons';
 
 import { useTranslation } from '../hooks/useTranslation';
 import { ToolCall } from '../types';
+import { formatToolResponseForMarkdown } from '../utils/formatToolResponseForMarkdown';
 
 interface ToolCallContentProps {
   toolCall: ToolCall;
@@ -55,7 +56,10 @@ export const ToolCallContent = ({
   const getParameterKeys = (): string[] => {
     if (!toolCall.arguments) return [];
     return Object.keys(toolCall.arguments).filter(
-      key => toolCall.arguments[key] !== '' && toolCall.arguments[key] !== null,
+      key =>
+        key !== 'server_label' &&
+        toolCall.arguments[key] !== '' &&
+        toolCall.arguments[key] !== null,
     );
   };
 
@@ -69,6 +73,14 @@ export const ToolCallContent = ({
   const thinkingTime = getThinkingTime();
   const parameterKeys = getParameterKeys();
 
+  const mcpServerTitle = (() => {
+    const label = toolCall.arguments?.server_label;
+    if (typeof label === 'string' && label.trim() !== '') {
+      return label.trim();
+    }
+    return t('toolCall.mcpServer');
+  })();
+
   return (
     <Flex
       direction={{ default: 'column' }}
@@ -120,7 +132,7 @@ export const ToolCallContent = ({
                     marginRight: '0.5em',
                   }}
                 />
-                <strong>{t('toolCall.mcpServer')}</strong>
+                <strong>{mcpServerTitle}</strong>
               </Content>
               {toolCall.executionTime !== undefined && (
                 <Content component={ContentVariants.small}>
@@ -215,12 +227,14 @@ export const ToolCallContent = ({
                       >
                         <FlexItem>
                           <Message
-                            content={toolCall.response}
+                            content={formatToolResponseForMarkdown(
+                              toolCall.response,
+                            )}
                             role={role}
                             codeBlockProps={{
                               isExpandable: true,
                               expandableSectionProps: {
-                                truncateMaxLines: 1,
+                                truncateMaxLines: 12,
                               },
                             }}
                           />

workspaces/lightspeed/plugins/lightspeed/src/components/__tests__/ToolCallContent.test.tsx

@@ -179,4 +179,19 @@ describe('ToolCallContent', () => {
     const parentContent = mcpServerText.closest('p');
     expect(parentContent?.querySelector('svg')).toBeInTheDocument();
   });
+
+  test('should show server_label from arguments instead of default MCP Server label', () => {
+    const toolCall: ToolCall = {
+      ...baseToolCall,
+      arguments: {
+        ...baseToolCall.arguments,
+        server_label: 'mcp::backstage',
+      },
+    };
+
+    render(<ToolCallContent toolCall={toolCall} />);
+
+    expect(screen.getByText('mcp::backstage')).toBeInTheDocument();
+    expect(screen.queryByText('MCP Server')).not.toBeInTheDocument();
+  });
 });

workspaces/lightspeed/plugins/lightspeed/src/hooks/__tests__/useConversationMessages.test.tsx

@@ -560,6 +560,143 @@ data: {"event": "token", "data": {"id": 2, "token": ""}}\n
     expect(onComplete).toHaveBeenCalledWith('Hi from conversation 1!');
   });
 
+  it('should parse MCP-style tool_call and tool_result (name/args and content)', async () => {
+    const toolCallId = 'mcp_list_67d3a067-e262-4bef-b467-6c82f622bd4a';
+    const mcpStream = createSSEStream([
+      {
+        event: 'start',
+        data: { conversation_id: 'conv-mcp' },
+      },
+      {
+        event: 'tool_call',
+        data: {
+          id: toolCallId,
+          name: 'mcp_list_tools',
+          args: { server_label: 'mcp-integration-tools' },
+          type: 'mcp_list_tools',
+        },
+      },
+      {
+        event: 'tool_result',
+        data: {
+          id: toolCallId,
+          status: 'success',
+          content: '{"server_label":"mcp-integration-tools","tools":[]}',
+        },
+      },
+      {
+        event: 'token',
+        data: { id: 0, token: 'Done.' },
+      },
+    ]);
+
+    const mockApi = {
+      createMessage: jest.fn().mockResolvedValue({
+        read: jest
+          .fn()
+          .mockResolvedValueOnce({
+            done: false,
+            value: new TextEncoder().encode(mcpStream),
+          })
+          .mockResolvedValueOnce({ done: true, value: null }),
+      }),
+    };
+    (useApi as jest.Mock).mockReturnValue(mockApi);
+
+    const { result } = renderHook(
+      () =>
+        useConversationMessages(
+          'conv-mcp',
+          'test-user',
+          'gpt-4',
+          'openai',
+          'user.png',
+        ),
+      { wrapper },
+    );
+
+    await act(async () => {
+      await result.current.handleInputPrompt('List MCP tools');
+    });
+
+    await waitFor(() => {
+      const msgs = result.current.conversations['conv-mcp'];
+      const bot = msgs?.[1];
+      expect(bot?.toolCalls).toHaveLength(1);
+      expect(bot?.toolCalls?.[0]).toEqual(
+        expect.objectContaining({
+          id: toolCallId,
+          toolName: 'mcp_list_tools',
+          arguments: { server_label: 'mcp-integration-tools' },
+          response: '{"server_label":"mcp-integration-tools","tools":[]}',
+          isLoading: false,
+        }),
+      );
+      expect(bot?.content).toContain('Done.');
+    });
+  });
+
+  it('should complete legacy tool_result when response field is omitted', async () => {
+    const legacyStream = createSSEStream([
+      {
+        event: 'start',
+        data: { conversation_id: 'conv-legacy-res' },
+      },
+      {
+        event: 'tool_call',
+        data: {
+          id: 1,
+          token: { tool_name: 'fetch-techdocs', arguments: { owner: 'a' } },
+        },
+      },
+      {
+        event: 'tool_result',
+        data: { id: 1, token: { tool_name: 'fetch-techdocs' } },
+      },
+    ]);
+
+    const mockApi = {
+      createMessage: jest.fn().mockResolvedValue({
+        read: jest
+          .fn()
+          .mockResolvedValueOnce({
+            done: false,
+            value: new TextEncoder().encode(legacyStream),
+          })
+          .mockResolvedValueOnce({ done: true, value: null }),
+      }),
+    };
+    (useApi as jest.Mock).mockReturnValue(mockApi);
+
+    const { result } = renderHook(
+      () =>
+        useConversationMessages(
+          'conv-legacy-res',
+          'test-user',
+          'gpt-4',
+          'openai',
+          'user.png',
+        ),
+      { wrapper },
+    );
+
+    await act(async () => {
+      await result.current.handleInputPrompt('techdocs');
+    });
+
+    await waitFor(() => {
+      const msgs = result.current.conversations['conv-legacy-res'];
+      const bot = msgs?.[1];
+      expect(bot?.toolCalls?.[0]).toEqual(
+        expect.objectContaining({
+          toolName: 'fetch-techdocs',
+          response: '',
+          isLoading: false,
+        }),
+      );
+    });
+  });
+
   it('should resume streaming for the first conversation after switching back and complete', async () => {
     const onComplete = jest.fn();