[chat][AI] add proxy route for ml commons (#10875)

* refactor(chat): implement server-side proxy for AG-UI communication

Signed-off-by: Ashwin P Chandran <[email protected]>

* Changeset file for PR #10826 created/updated

Signed-off-by: Ashwin P Chandran <[email protected]>

* fixes tests

Signed-off-by: Ashwin P Chandran <[email protected]>

* [chat][AI] add proxy route for ml commons

Signed-off-by: Anan Zhuang <[email protected]>

* fix PR comment

Signed-off-by: Anan Zhuang <[email protected]>

---------

Signed-off-by: Ashwin P Chandran <[email protected]>
Signed-off-by: Anan Zhuang <[email protected]>
Co-authored-by: Ashwin P Chandran <[email protected]>
Co-authored-by: opensearch-changeset-bot[bot] <154024398+opensearch-changeset-bot[bot]@users.noreply.github.com>

Author: 3 people

changelogs/fragments/10826.yml

@@ -0,0 +1,2 @@
+chore:
+- Proxies the AG-UI calls via the node server ([#10826](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/10826))

config/opensearch_dashboards.yml

@@ -410,6 +410,7 @@
 # chat:
   # enabled: true
   # agUiUrl: "http://your-ai-agent-url:port"
+  # mlCommonsAgentId: "olly-chat-agent-id"
 
 # @experimental Set the value to true to enable context provider
 # contextProvider:

src/plugins/chat/public/plugin.test.ts

@@ -78,10 +78,11 @@ describe('ChatPlugin', () => {
   });
 
   describe('start', () => {
-    it('should initialize chat service with configured AG-UI URL', () => {
+    it('should initialize chat service when enabled', () => {
       plugin.start(mockCoreStart, mockDeps);
 
-      expect(ChatService).toHaveBeenCalledWith('http://test-ag-ui:3000');
+      // ChatService is called without arguments (uses proxy endpoint)
+      expect(ChatService).toHaveBeenCalledWith();
     });
 
     it('should register chat button in header nav controls', () => {
@@ -100,14 +101,17 @@ describe('ChatPlugin', () => {
       expect(startContract.chatService).toBeInstanceOf(ChatService);
     });
 
-    it('should handle missing AG-UI URL configuration', () => {
+    it('should initialize chat service even without agUiUrl config', () => {
+      // agUiUrl is server-side config only; client doesn't need it
       mockInitializerContext.config.get = jest.fn().mockReturnValue({ enabled: true });
+      const testPlugin = new ChatPlugin(mockInitializerContext);
 
-      const startContract = plugin.start(mockCoreStart, mockDeps);
+      const startContract = testPlugin.start(mockCoreStart, mockDeps);
 
-      expect(ChatService).not.toHaveBeenCalled();
-      expect(startContract.chatService).toBeUndefined();
-      expect(mockCoreStart.chrome.navControls.registerRight).not.toHaveBeenCalled();
+      // ChatService should still be created (uses proxy endpoint)
+      expect(ChatService).toHaveBeenCalledWith();
+      expect(startContract.chatService).toBeInstanceOf(ChatService);
+      expect(mockCoreStart.chrome.navControls.registerRight).toHaveBeenCalled();
     });
 
     it('should not initialize when plugin is disabled', () => {
@@ -272,19 +276,22 @@ describe('ChatPlugin', () => {
         { enabled: true, agUiUrl: 'http://localhost:3000' },
         { enabled: true, agUiUrl: 'https://remote-server:8080' },
         { enabled: false, agUiUrl: 'http://localhost:3000' },
-        { enabled: true }, // Missing agUiUrl
+        { enabled: true }, // Missing agUiUrl (still works with proxy)
         {}, // Missing both enabled and agUiUrl
       ];
 
-      configs.forEach((config) => {
+      configs.forEach((config, index) => {
+        jest.clearAllMocks();
         mockInitializerContext.config.get = jest.fn().mockReturnValue(config);
         const testPlugin = new ChatPlugin(mockInitializerContext);
 
         expect(() => testPlugin.start(mockCoreStart, mockDeps)).not.toThrow();
 
-        // Only first two configs should initialize the service
-        if (config.enabled && config.agUiUrl) {
-          expect(ChatService).toHaveBeenCalledWith(config.agUiUrl);
+        // ChatService is initialized whenever enabled is true (regardless of agUiUrl)
+        if (config.enabled) {
+          expect(ChatService).toHaveBeenCalledWith();
+        } else {
+          expect(ChatService).not.toHaveBeenCalled();
         }
       });
     });

src/plugins/chat/public/plugin.ts

@@ -34,17 +34,17 @@ export class ChatPlugin implements Plugin<ChatPluginSetup, ChatPluginStart> {
     // Get configuration
     const config = this.initializerContext.config.get<{ enabled: boolean; agUiUrl?: string }>();
 
-    // Check if chat plugin is enabled and has required agUiUrl
-    if (!config.enabled || !config.agUiUrl) {
+    // Check if chat plugin is enabled
+    if (!config.enabled) {
       return {
         chatService: undefined,
       };
     }
 
     const chatHeaderButtonRef = React.createRef<ChatHeaderButtonInstance>();
 
-    // Initialize chat service with configured AG-UI URL
-    this.chatService = new ChatService(config.agUiUrl);
+    // Initialize chat service (it will use the server proxy)
+    this.chatService = new ChatService();
 
     // Store reference to chat service for use in subscription
     const chatService = this.chatService;

src/plugins/chat/public/services/ag_ui_agent.test.ts

@@ -73,6 +73,7 @@ describe('AgUiAgent', () => {
             headers: {
               'Content-Type': 'application/json',
               Accept: 'text/event-stream',
+              'osd-xsrf': 'true',
             },
             body: JSON.stringify(mockInput),
             signal: expect.any(AbortSignal),

src/plugins/chat/public/services/ag_ui_agent.ts

@@ -20,13 +20,13 @@ export enum EventType {
 }
 
 export class AgUiAgent {
-  private serverUrl: string;
+  private proxyUrl: string;
   private abortController?: AbortController;
   private sseBuffer: string = '';
   private activeConnection: boolean = false;
 
-  constructor(serverUrl: string = 'http://localhost:3000') {
-    this.serverUrl = serverUrl;
+  constructor(proxyUrl: string = '/api/chat/proxy') {
+    this.proxyUrl = proxyUrl;
   }
 
   public runAgent(input: RunAgentInput): Observable<BaseEvent> {
@@ -46,12 +46,13 @@ export class AgUiAgent {
       // Set active connection flag
       this.activeConnection = true;
 
-      // Make request to AG-UI server
-      fetch(this.serverUrl, {
+      // Make request to OpenSearch Dashboards proxy endpoint
+      fetch(this.proxyUrl, {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
           Accept: 'text/event-stream',
+          'osd-xsrf': 'true', // Required for OpenSearch Dashboards API calls
         },
         body: JSON.stringify(input),
         signal: this.abortController.signal,
@@ -110,7 +111,7 @@ export class AgUiAgent {
           }
 
           // eslint-disable-next-line no-console
-          console.error('AG-UI request failed:', error.message);
+          console.error('Chat proxy request failed:', error.message);
 
           observer.next({
             type: EventType.RUN_ERROR,

src/plugins/chat/public/services/chat_service.test.ts

@@ -30,25 +30,14 @@ describe('ChatService', () => {
     // Mock AgUiAgent constructor
     (AgUiAgent as jest.MockedClass<typeof AgUiAgent>).mockImplementation(() => mockAgent);
 
-    chatService = new ChatService('http://test-server');
+    chatService = new ChatService();
   });
 
   afterEach(() => {
     jest.restoreAllMocks();
   });
 
   describe('constructor', () => {
-    it('should create instance with default server URL', () => {
-      const service = new ChatService();
-      expect(AgUiAgent).toHaveBeenCalledWith(undefined);
-    });
-
-    it('should create instance with custom server URL', () => {
-      const customUrl = 'http://custom-server:8080';
-      const service = new ChatService(customUrl);
-      expect(AgUiAgent).toHaveBeenCalledWith(customUrl);
-    });
-
     it('should initialize with empty available tools', () => {
       expect(chatService.availableTools).toEqual([]);
     });

src/plugins/chat/public/services/chat_service.ts

@@ -39,8 +39,9 @@ export class ChatService {
   // ChatWindow ref for delegating sendMessage calls to proper timeline management
   private chatWindowRef: React.RefObject<ChatWindowInstance> | null = null;
 
-  constructor(serverUrl?: string) {
-    this.agent = new AgUiAgent(serverUrl);
+  constructor() {
+    // No need to pass URL anymore - agent will use the proxy endpoint
+    this.agent = new AgUiAgent();
     this.threadId = this.generateThreadId();
   }
 

src/plugins/chat/server/config.ts

@@ -8,6 +8,7 @@ import { schema, TypeOf } from '@osd/config-schema';
 export const configSchema = schema.object({
   enabled: schema.boolean({ defaultValue: false }),
   agUiUrl: schema.maybe(schema.string()),
+  mlCommonsAgentId: schema.maybe(schema.string()),
 });
 
 export type ChatConfigType = TypeOf<typeof configSchema>;

src/plugins/chat/server/plugin.ts

@@ -3,40 +3,58 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { Observable } from 'rxjs';
+import { first } from 'rxjs/operators';
 import {
   PluginInitializerContext,
   CoreSetup,
   CoreStart,
   Plugin,
   Logger,
+  OpenSearchDashboardsRequest,
 } from '../../../core/server';
 
 import { ChatPluginSetup, ChatPluginStart } from './types';
 import { defineRoutes } from './routes';
+import { ChatConfigType } from './config';
 
 /**
  * @experimental
  * Chat plugin for AI-powered interactions. This plugin is experimental and will change in future releases.
  */
 export class ChatPlugin implements Plugin<ChatPluginSetup, ChatPluginStart> {
   private readonly logger: Logger;
+  private readonly config$: Observable<ChatConfigType>;
+  private capabilitiesResolver?: (request: OpenSearchDashboardsRequest) => Promise<Capabilities>;
 
   constructor(initializerContext: PluginInitializerContext) {
     this.logger = initializerContext.logger.get();
+    this.config$ = initializerContext.config.create<ChatConfigType>();
   }
 
-  public setup(core: CoreSetup) {
+  public async setup(core: CoreSetup) {
     this.logger.debug('chat: Setup');
+    const config = await this.config$.pipe(first()).toPromise();
     const router = core.http.createRouter();
+    const getCapabilitiesResolver = () => this.capabilitiesResolver;
 
-    // Register server side APIs
-    defineRoutes(router);
+    defineRoutes(
+      router,
+      this.logger,
+      config.agUiUrl,
+      getCapabilitiesResolver,
+      config.mlCommonsAgentId
+    );
 
     return {};
   }
 
   public start(core: CoreStart) {
     this.logger.debug('chat: Started');
+
+    this.capabilitiesResolver = (request: OpenSearchDashboardsRequest) =>
+      core.capabilities.resolveCapabilities(request);
+
     return {};
   }