AI: Init, add .d.ts, add separate build, add tests

packages/devextreme-angular/src/common/ai-integration/index.ts

@@ -0,0 +1,7 @@
+export {
+    AIIntegration,
+    AIProvider,
+    Prompt,
+    RequestParams,
+    Response,
+} from 'devextreme/common/ai-integration';

packages/devextreme-angular/src/common/ai-integration/ng-package.json

@@ -0,0 +1,5 @@
+{
+  "lib": {
+    "entryFile": "index.ts"
+  }
+}

packages/devextreme-angular/src/common/index.ts

@@ -74,6 +74,7 @@ export {
     VerticalEdge,
 } from 'devextreme/common';
 
+export * as AiIntegration from './ai-integration';
 export * as Charts from './charts';
 export * as Core from './core/index';
 export * as Data from './data';

packages/devextreme-react/src/common/ai-integration.ts

@@ -0,0 +1,7 @@
+export {
+    AIIntegration,
+    AIProvider,
+    Prompt,
+    RequestParams,
+    Response,
+} from "devextreme/common/ai-integration";

packages/devextreme-react/src/common/index.ts

@@ -74,6 +74,7 @@ export {
     VerticalEdge,
 } from "devextreme/common";
 
+export * as AiIntegration from "./ai-integration";
 export * as Charts from "./charts";
 export * as Core from "./core/index";
 export * as Data from "./data";

packages/devextreme-vue/src/common/ai-integration.ts

@@ -0,0 +1,7 @@
+export {
+    AIIntegration,
+    AIProvider,
+    Prompt,
+    RequestParams,
+    Response,
+} from "devextreme/common/ai-integration";

packages/devextreme-vue/src/common/index.ts

@@ -74,6 +74,7 @@ export {
     VerticalEdge,
 } from "devextreme/common";
 
+export * as AiIntegration from "./ai-integration";
 export * as Charts from "./charts";
 export * as Core from "./core/index";
 export * as Data from "./data";

packages/devextreme/build/gulp/js-bundles.js

@@ -20,6 +20,7 @@ const namedDebug = lazyPipe()
     .pipe(named, (file) => path.basename(file.path, path.extname(file.path)) + '.debug');
 
 const BUNDLES = [
+    '/bundles/dx.ai-integration.js',
     '/bundles/dx.all.js',
     '/bundles/dx.web.js',
     '/bundles/dx.viz.js'
@@ -53,8 +54,10 @@ const jsBundlesProd = (src, dist, bundles) => (() =>
 );
 
 gulp.task('js-bundles-prod',
-    jsBundlesProd(ctx.TRANSPILED_PROD_RENOVATION_PATH,
-        ctx.RESULT_JS_PATH, BUNDLES
+    jsBundlesProd(
+        ctx.TRANSPILED_PROD_RENOVATION_PATH,
+        ctx.RESULT_JS_PATH,
+        BUNDLES,
     )
 );
 

packages/devextreme/js/__internal/core/ai_integration/commands/base.test.ts

@@ -0,0 +1,223 @@
+import {
+  beforeEach,
+  describe,
+  expect,
+  it,
+  jest,
+} from '@jest/globals';
+import type { AIProvider, RequestCallbacks } from '@js/common/ai-integration';
+import { BaseCommand } from '@ts/core/ai_integration/commands/base';
+import type { PromptData, PromptTemplateName } from '@ts/core/ai_integration/core/prompt_manager';
+import { PromptManager } from '@ts/core/ai_integration/core/prompt_manager';
+import { RequestManager } from '@ts/core/ai_integration/core/request_manager';
+import { Provider } from '@ts/core/ai_integration/test_utils/provider_mock';
+
+jest.mock('@ts/core/ai_integration/templates/index', () => ({
+  templates: {
+    'test-template-name': {
+      system: 'System test template with {{first}}',
+      user: 'User test template with {{second}}',
+    },
+  },
+}));
+
+interface TestCommandParams {
+  first: string;
+  second: string;
+}
+
+class TestCommand extends BaseCommand<TestCommandParams, string> {
+  getTemplateName(): PromptTemplateName {
+    return 'test-template-name' as PromptTemplateName;
+  }
+
+  buildPromptData(params: TestCommandParams): PromptData {
+    const data = {
+      system: { first: params?.first },
+      user: { second: params?.second },
+    };
+
+    return data;
+  }
+
+  parseResult(response: string): string {
+    return `Parsed result: ${response}`;
+  }
+}
+
+describe('BaseCommand', () => {
+  let promptManager = null as unknown as PromptManager;
+  let requestManager = null as unknown as RequestManager;
+  let command = null as unknown as TestCommand;
+
+  const params: TestCommandParams = { first: 'first', second: 'second' };
+
+  beforeEach(() => {
+    const provider: AIProvider = new Provider();
+
+    requestManager = new RequestManager(provider);
+    promptManager = new PromptManager();
+
+    command = new TestCommand(promptManager, requestManager);
+  });
+
+  describe('constructor', () => {
+    it('stores PromptManager and RequestManager correctly', () => {
+      // @ts-expect-error Access to protected property for a test
+      expect(command.promptManager).toBe(promptManager);
+      // @ts-expect-error Access to protected property for a test
+      expect(command.requestManager).toBe(requestManager);
+    });
+  });
+
+  describe('execute', () => {
+    it('getTemplateName returns value correctly', () => {
+      const spy = jest.spyOn(command, 'getTemplateName');
+
+      command.execute(params, {});
+
+      expect(spy).toHaveBeenCalledTimes(1);
+      expect(spy).toHaveReturnedWith('test-template-name');
+    });
+
+    it('buildPromptData receives and returns correct data', () => {
+      const spy = jest.spyOn(command, 'buildPromptData');
+
+      command.execute(params, {});
+
+      expect(spy).toHaveBeenCalledTimes(1);
+      expect(spy).toHaveBeenCalledWith(params);
+      expect(spy).toHaveReturnedWith({
+        system: { first: params.first },
+        user: { second: params.second },
+      });
+    });
+
+    it('parseResult receives correct value and returns expected result', async () => {
+      const spy = jest.spyOn(command, 'parseResult');
+
+      command.execute(params, {});
+
+      await new Promise(process.nextTick);
+
+      expect(spy).toHaveBeenCalledTimes(1);
+      expect(spy).toHaveBeenCalledWith('AI response');
+      expect(spy).toHaveReturnedWith('Parsed result: AI response');
+    });
+
+    it('callbacks are called correctly', async () => {
+      const callbacks = {
+        onComplete: jest.fn(),
+        onError: jest.fn(),
+        onChunk: jest.fn(),
+      };
+
+      command.execute(params, callbacks as RequestCallbacks);
+
+      await new Promise(process.nextTick);
+
+      expect(callbacks.onComplete).toHaveBeenCalledTimes(1);
+      expect(callbacks.onError).toHaveBeenCalledTimes(0);
+      expect(callbacks.onChunk).toHaveBeenCalledTimes(2);
+    });
+
+    it('onComplete is called with parseResult output', async () => {
+      const callbacks = { onComplete: jest.fn() };
+
+      command.execute(params, callbacks as RequestCallbacks);
+
+      await new Promise(process.nextTick);
+
+      expect(callbacks.onComplete).toHaveBeenCalledWith('Parsed result: AI response');
+    });
+
+    it('calls onError if request fails', async () => {
+      const originalSendRequest = requestManager.sendRequest;
+
+      requestManager.sendRequest = (_, callbacks) => {
+        callbacks.onError?.(new Error('Test error'));
+
+        return (): void => {};
+      };
+
+      try {
+        const callbacks = {
+          onError: jest.fn(),
+          onComplete: jest.fn(),
+        };
+
+        command.execute(params, callbacks as RequestCallbacks);
+
+        await new Promise(process.nextTick);
+
+        expect(callbacks.onError).toHaveBeenCalledTimes(1);
+        expect(callbacks.onError).toHaveBeenCalledWith(new Error('Test error'));
+        expect(callbacks.onComplete).toHaveBeenCalledTimes(0);
+      } finally {
+        requestManager.sendRequest = originalSendRequest;
+      }
+    });
+
+    it('calls onChunk for each chunk and onComplete correctly', () => {
+      const originalSendRequest = requestManager.sendRequest;
+
+      requestManager.sendRequest = (_, callbacks) => {
+        callbacks.onChunk?.('first');
+        callbacks.onChunk?.('second');
+        callbacks.onComplete?.('first second');
+
+        return (): void => {};
+      };
+
+      try {
+        const onChunk = jest.fn();
+        const onComplete = jest.fn();
+
+        command.execute(params, { onChunk, onComplete });
+
+        expect(onChunk).toHaveBeenCalledTimes(2);
+        expect(onChunk).toHaveBeenNthCalledWith(1, 'first');
+        expect(onChunk).toHaveBeenNthCalledWith(2, 'second');
+        expect(onComplete).toHaveBeenCalledTimes(1);
+        expect(onComplete).toHaveBeenNthCalledWith(1, 'Parsed result: first second');
+      } finally {
+        requestManager.sendRequest = originalSendRequest;
+      }
+    });
+
+    it('executes with undefined params without errors', async () => {
+      const sendRequestSpy = jest.spyOn(requestManager, 'sendRequest');
+      const onError = jest.fn();
+
+      expect(command.execute(undefined as unknown as TestCommandParams, { onError })).not.toThrow();
+
+      await new Promise(process.nextTick);
+
+      expect(onError).toHaveBeenCalledTimes(0);
+      expect(sendRequestSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it('executes with partial callbacks without errors', async () => {
+      const sendRequestSpy = jest.spyOn(requestManager, 'sendRequest');
+      const callbacks = { onChunk: jest.fn() };
+
+      expect(command.execute(params, callbacks)).not.toThrow();
+
+      await new Promise(process.nextTick);
+
+      expect(callbacks.onChunk).toHaveBeenCalledTimes(2);
+      expect(sendRequestSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it('executes with undefined callbacks without errors', () => {
+      const sendRequestSpy = jest.spyOn(requestManager, 'sendRequest');
+
+      expect(command.execute(
+        params,
+        (undefined as unknown as RequestCallbacks),
+      )).not.toThrow();
+
+      expect(sendRequestSpy).toHaveBeenCalledTimes(1);
+    });
+  });
+});

packages/devextreme/js/__internal/core/ai_integration/commands/base.ts

@@ -0,0 +1,33 @@
+import type { BaseCommandResult, RequestCallbacks } from '@js/common/ai-integration';
+import type { PromptData, PromptManager, PromptTemplateName } from '@ts/core/ai_integration/core/prompt_manager';
+import type { RequestManager } from '@ts/core/ai_integration/core/request_manager';
+
+export abstract class BaseCommand<TParams, TResult extends BaseCommandResult> {
+  constructor(
+    protected promptManager: PromptManager,
+    protected requestManager: RequestManager,
+  ) {}
+
+  public execute(params: TParams, callbacks: RequestCallbacks): () => void {
+    const templateName = this.getTemplateName();
+    const data = this.buildPromptData(params);
+
+    const prompt = this.promptManager.buildPrompt(templateName, data);
+
+    const abort = this.requestManager.sendRequest(prompt, {
+      onChunk: (chunk) => { callbacks?.onChunk?.(chunk); },
+      onComplete: (result) => {
+        const finalResponse = this.parseResult(result);
+
+        callbacks?.onComplete?.(finalResponse);
+      },
+      onError: (error) => { callbacks?.onError?.(error); },
+    });
+
+    return abort;
+  }
+
+  protected abstract getTemplateName(): PromptTemplateName;
+  protected abstract buildPromptData(params: TParams): PromptData;
+  protected abstract parseResult(response: string): TResult;
+}