From eb26e963c70f2db8bb39e480e783e82b97f37725 Mon Sep 17 00:00:00 2001
From: Diana Gromova <16adianay@gmail.com>
Date: Wed, 2 Sep 2026 19:02:08 +0400
Subject: [PATCH 1/7] Add Chat - Custom AI Assistant demo

---
 .../CustomAIAssistant/jQuery/ai-service.js    |  80 ++++
 .../CustomAIAssistant/jQuery/chat-router.js   | 272 ++++++++++++++
 .../Chat/CustomAIAssistant/jQuery/data.js     |  87 +++++
 .../CustomAIAssistant/jQuery/form-commands.js |  89 +++++
 .../CustomAIAssistant/jQuery/grid-commands.js | 286 ++++++++++++++
 .../Chat/CustomAIAssistant/jQuery/index.html  |  36 ++
 .../Chat/CustomAIAssistant/jQuery/index.js    | 349 ++++++++++++++++++
 .../Chat/CustomAIAssistant/jQuery/styles.css  |  68 ++++
 apps/demos/menuMeta.json                      |  29 ++
 9 files changed, 1296 insertions(+)
 create mode 100644 apps/demos/Demos/Chat/CustomAIAssistant/jQuery/ai-service.js
 create mode 100644 apps/demos/Demos/Chat/CustomAIAssistant/jQuery/chat-router.js
 create mode 100644 apps/demos/Demos/Chat/CustomAIAssistant/jQuery/data.js
 create mode 100644 apps/demos/Demos/Chat/CustomAIAssistant/jQuery/form-commands.js
 create mode 100644 apps/demos/Demos/Chat/CustomAIAssistant/jQuery/grid-commands.js
 create mode 100644 apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.html
 create mode 100644 apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.js
 create mode 100644 apps/demos/Demos/Chat/CustomAIAssistant/jQuery/styles.css

diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/ai-service.js b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/ai-service.js
new file mode 100644
index 000000000000..844db2d9c648
--- /dev/null
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/ai-service.js
@@ -0,0 +1,80 @@
+function createAiIntegration() {
+  const aiService = new AzureOpenAI({
+    dangerouslyAllowBrowser: true,
+    deployment,
+    endpoint,
+    apiVersion,
+    apiKey,
+  });
+
+  async function getAIResponse(messages, signal) {
+    const params = {
+      messages,
+      model: deployment,
+      max_completion_tokens: 1000,
+      temperature: 0,
+    };
+
+    const response = await aiService.chat.completions.create(params, {
+      signal,
+    });
+
+    return response.choices[0].message?.content;
+  }
+
+  async function getAIResponseRecursive(messages, signal) {
+    return getAIResponse(messages, signal).catch(async (error) => {
+      if (!error.message.includes("Connection error")) {
+        throw error;
+      }
+
+      DevExpress.ui.notify({
+        message:
+          "Our demo AI service reached a temporary request limit. Retrying in 30 seconds.",
+        width: "auto",
+        type: "error",
+        displayTime: 5000,
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 30000));
+
+      return getAIResponseRecursive(messages, signal);
+    });
+  }
+
+  return new DevExpress.aiIntegration.AIIntegration({
+    sendRequest({ prompt, data }) {
+      const isValidRequest = JSON.stringify(prompt.user).length < 20000;
+      if (!isValidRequest) {
+        return {
+          promise: Promise.reject(
+            new ChatCommandError(
+              "❌ This message is too long for me to process. Please shorten it and try again.",
+            ),
+          ),
+          abort: () => {},
+        };
+      }
+      const controller = new AbortController();
+      const signal = controller.signal;
+
+      const isSmartPasteRequest = Array.isArray(data?.fields);
+      const system = isSmartPasteRequest
+        ? `${prompt.system ?? ""} IMPORTANT: reply on a SINGLE line with no line breaks of any kind - use ";;;" as the only separator between fields.`
+        : (prompt.system ?? "");
+
+      const aiPrompt = [
+        { role: "system", content: system },
+        { role: "user", content: prompt.user },
+      ];
+      const promise = getAIResponseRecursive(aiPrompt, signal);
+
+      return {
+        promise,
+        abort: () => {
+          controller.abort();
+        },
+      };
+    },
+  });
+}
diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/chat-router.js b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/chat-router.js
new file mode 100644
index 000000000000..0a6fde992ad8
--- /dev/null
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/chat-router.js
@@ -0,0 +1,272 @@
+class ChatCommandError extends Error {}
+
+function extractJson(text) {
+  const match = text.match(/\{[\s\S]*\}/);
+
+  try {
+    return JSON.parse(match[0]);
+  } catch {
+    throw new ChatCommandError(
+      "❌ I received an unexpected response from the AI service. Please rephrase your request and try again.",
+    );
+  }
+}
+
+function executeAiCommand(text, aiIntegration) {
+  return new Promise((resolve, reject) => {
+    aiIntegration.execute(
+      { text },
+      {
+        onComplete: (finalResponse) => {
+          try {
+            resolve(extractJson(finalResponse));
+          } catch (error) {
+            reject(error);
+          }
+        },
+        onError: reject,
+      },
+    );
+  });
+}
+
+function buildGridSystemPrompt(columnNames) {
+  return [
+    "You control a task DataGrid on this page.",
+    "This page ALSO has a separate employee/customer profile form (fields like name, title/prefix, " +
+      "position, state, birth date) that is handled elsewhere - it is NOT part of this grid.",
+    "Figure out what the user's request is about and translate ONLY the part that is clearly about " +
+      "the task grid into the matching commands described below.",
+    "Do NOT create a grid action just because a value could technically fit a text column (e.g. " +
+      '"Subject"). If the request is about the profile form (e.g. mentions a person\'s name, title, ' +
+      'job position, state, or birth date), leave that part out of "actions" entirely - even if no ' +
+      "other part of the request is grid-related.",
+    "",
+    buildGridPromptSection(columnNames),
+    "",
+    "Respond with STRICT JSON only, no code fences, no explanations, matching this schema:",
+    JSON.stringify(buildGridResponseSchema()),
+    "",
+    'If the request has nothing to do with the grid, respond with "actions": [].',
+  ].join("\n");
+}
+
+const FIELD_OR_VALUE_NOT_FOUND_MESSAGE =
+  "❌ No field or column exists with such a name, or the entered value is invalid. Please check the name and value and try again.";
+
+const MAX_USER_MESSAGE_LENGTH = 2000;
+const ROUTER_TARGETS = new Set(["form", "grid", "mixed", "none"]);
+const FORM_ACTION_TYPES = new Set(["clear_field", "clear_all", "smart_paste"]);
+
+function buildFormActionPromptSection(form) {
+  const fieldList = getFormFieldOptions(form)
+    .map((f) => `${f.dataField} (${f.label})`)
+    .join(", ");
+
+  return [
+    `Form fields (dataField and label): ${fieldList}.`,
+    'If the request is about the form, also set "formAction" to one of:',
+    '- {"type": "clear_field", "field": "<dataField>"} to clear one specific field.',
+    '- {"type": "clear_all"} to clear/reset the whole form.',
+    '- {"type": "smart_paste"} to fill in form data from the request text.',
+    'Set "formAction" to null if the request is not about the form.',
+  ].join("\n");
+}
+
+async function classifyRequest(text, aiIntegration, form) {
+  if (!aiIntegration) {
+    return { target: "mixed", formAction: null };
+  }
+
+  const prompt = [
+    "Decide which UI area should handle the user's request.",
+    "Return STRICT JSON only, without markdown fences.",
+    'Format: {"target": "form" | "grid" | "mixed" | "none", "formAction": <see below> | null, "reason": "short explanation" }',
+    "Rules:",
+    "- Use form for profile/customer form updates, field clearing, or smart-paste style data entry.",
+    "- Use grid for sorting, filtering, showing/hiding columns, or other DataGrid tasks.",
+    "- Use mixed when the request clearly asks for both a form change and a grid change together.",
+    "- Use none when the request is unrelated to both areas.",
+    "If you are not confident, return mixed.",
+    "",
+    buildFormActionPromptSection(form),
+    "",
+    `User request: "${text}"`,
+  ].join("\n");
+
+  try {
+    const parsed = await executeAiCommand(prompt, aiIntegration);
+    const target = String(parsed?.target ?? "mixed")
+      .trim()
+      .toLowerCase();
+    const rawFormAction = parsed?.formAction;
+    const formAction =
+      rawFormAction && FORM_ACTION_TYPES.has(rawFormAction.type)
+        ? rawFormAction
+        : null;
+
+    return {
+      target: ROUTER_TARGETS.has(target) ? target : "mixed",
+      formAction,
+    };
+  } catch {
+    return { target: "mixed", formAction: null };
+  }
+}
+
+function buildGridResultsPromise(gridInstance, aiIntegration, text) {
+  const columnNames = getGridColumnNames(gridInstance);
+  const prompt = `${buildGridSystemPrompt(columnNames)}\n\nUser request: "${text}"`;
+
+  return executeAiCommand(prompt, aiIntegration)
+    .then((parsed) => {
+
+      const actions = Array.isArray(parsed.actions) ? parsed.actions : [];
+
+      if (actions.length === 0) {
+        gridInstance?.endCustomLoading();
+        return { results: [], error: null };
+      }
+
+      try {
+        return {
+          results: applyGridActions(gridInstance, actions, text),
+          error: null,
+        };
+      } finally {
+        gridInstance?.endCustomLoading();
+      }
+    })
+    .catch((error) => {
+      gridInstance?.endCustomLoading();
+      return { results: [], error };
+    });
+}
+
+function buildFormResultsPromise(form, formAction, text) {
+  const clearResult = applyFormClearAction(form, formAction);
+  if (clearResult) {
+    return Promise.resolve({ results: [clearResult], error: null });
+  }
+
+  return applyFormSmartPaste(form, text)
+    .then((result) => ({ results: [result], error: null }))
+    .catch((error) => ({ results: [], error }));
+}
+
+function formatFailures(failed) {
+  return failed.map((message) => `❌ ${message}`).join("\n");
+}
+
+function formatSucceeded(succeeded) {
+  return succeeded.map((message) => `✅ Done. ${message}`).join("\n");
+}
+
+function joinSucceededOrThrow(results, fallbackError) {
+  const succeeded = results
+    .filter((r) => r.status === "success")
+    .map((r) => r.message);
+  const failed = results
+    .filter((r) => r.status === "failure")
+    .map((r) => r.message);
+
+  if (succeeded.length === 0) {
+    throw failed.length > 0
+      ? new ChatCommandError(formatFailures(failed))
+      : (fallbackError ?? new ChatCommandError(FIELD_OR_VALUE_NOT_FOUND_MESSAGE));
+  }
+
+  return failed.length > 0
+    ? `${formatSucceeded(succeeded)}\n${formatFailures(failed)}`
+    : formatSucceeded(succeeded);
+}
+
+async function runCommand(text, { form, gridInstance, aiIntegration }) {
+  if (text.length > MAX_USER_MESSAGE_LENGTH) {
+    return Promise.reject(
+      new ChatCommandError(
+        "❌ This message is too long for me to process. Please shorten it and try again.",
+      ),
+    );
+  }
+
+  const { target, formAction } = await classifyRequest(
+    text,
+    aiIntegration,
+    form,
+  );
+
+  if (target === "form") {
+    const { results: formResults, error: formError } =
+      await buildFormResultsPromise(form, formAction, text);
+
+    return joinSucceededOrThrow(formResults, formError);
+  }
+
+  if (target === "grid") {
+    gridInstance?.beginCustomLoading();
+
+    const { results: gridResults, error: gridError } =
+      await buildGridResultsPromise(gridInstance, aiIntegration, text);
+
+    return joinSucceededOrThrow(gridResults, gridError);
+  }
+
+  const [
+    { results: formResults, error: formError },
+    { results: gridResults, error: gridError },
+  ] = await Promise.all([
+    buildFormResultsPromise(form, formAction, text),
+    buildGridResultsPromise(gridInstance, aiIntegration, text),
+  ]);
+
+  if (gridError) {
+    console.warn(
+      "DataGrid AI request failed, but the Form request may have succeeded:",
+      gridError,
+    );
+  }
+
+  if (formError) {
+    console.warn(
+      "Form AI request failed, but the DataGrid request may have succeeded:",
+      formError,
+    );
+  }
+
+  return joinSucceededOrThrow(
+    [...formResults, ...gridResults],
+    gridError ?? formError,
+  );
+}
+
+function reportAiResult(promise, pushMessage) {
+  return promise
+    .then((message) => {
+      pushMessage({
+        author: { id: "ai", name: "AI Assistant" },
+        text: message,
+      });
+    })
+    .catch((error) => {
+      const text =
+        error instanceof ChatCommandError
+          ? error.message
+          : "❌ I couldn't reach the AI service. Please check your connection and try again.";
+
+      pushMessage({
+        author: { id: "ai", name: "AI Assistant" },
+        text,
+      });
+    });
+}
+
+function routeMessage(
+  text,
+  { form, gridInstance, aiIntegration, pushMessage },
+) {
+  return reportAiResult(
+    runCommand(text, { form, gridInstance, aiIntegration }),
+    pushMessage,
+  );
+}
diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/data.js b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/data.js
new file mode 100644
index 000000000000..bc5c56febde6
--- /dev/null
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/data.js
@@ -0,0 +1,87 @@
+const CLASSES = {
+  clearChatButton: "ai-chat-clear-button",
+};
+
+const deployment = "demo-mini";
+const apiVersion = "2024-02-01";
+const endpoint = "https://public-api.devexpress.com/demo-openai";
+const apiKey = "DEMO";
+
+const emptyViewMessage = "How can I help with this page?";
+const emptyViewPrompt =
+  "Update employee <b>Form</b> fields.\nFilter or sort tasks, display or hide <b>DataGrid</b> columns, or clear all filters and sorting."
+
+const titles = ["Mr.", "Mrs.", "Ms."];
+const colors = { High: "#F1BBBC", Normal: "#F9E2AE", Low: "#9FD89F" };
+const states = ["California", "New York", "Texas"];
+const positions = [
+  "CEO",
+  "Sales Assistant",
+  "CMO",
+  "Manager",
+  "Designer",
+  "Developer",
+];
+
+const employee = {
+  ID: 1,
+  Prefix: "Mr.",
+  FirstName: "John",
+  LastName: "Heart",
+  Position: "CEO",
+  State: "California",
+  BirthDate: "1964/03/16",
+};
+
+const tasks = [
+  {
+    ID: 5,
+    Subject: "Choose between PPO and HMO Health Plan",
+    StartDate: "2026/02/15",
+    DueDate: "2026/04/15",
+    Status: "In Progress",
+    Priority: "Low",
+    Completion: 75,
+    EmployeeID: 1,
+  },
+  {
+    ID: 6,
+    Subject: "Google AdWords Strategy",
+    StartDate: "2026/02/16",
+    DueDate: "2026/02/28",
+    Status: "Completed",
+    Priority: "High",
+    Completion: 100,
+    EmployeeID: 1,
+  },
+  {
+    ID: 7,
+    Subject: "New Brochures",
+    StartDate: "2026/02/17",
+    DueDate: "2026/02/24",
+    Status: "Completed",
+    Priority: "Normal",
+    Completion: 100,
+    EmployeeID: 1,
+  },
+  {
+    ID: 22,
+    Subject: "Update NDA Agreement",
+    StartDate: "2026/03/14",
+    DueDate: "2026/03/16",
+    Status: "Completed",
+    Priority: "High",
+    Completion: 100,
+    EmployeeID: 1,
+  },
+  {
+    ID: 52,
+    Subject: "Review Product Recall Report by Engineering Team",
+    StartDate: "2026/05/17",
+    DueDate: "2026/05/20",
+    Status: "Completed",
+    Priority: "High",
+    Completion: 100,
+    EmployeeID: 1,
+  },
+];
diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/form-commands.js b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/form-commands.js
new file mode 100644
index 000000000000..9be2a171b732
--- /dev/null
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/form-commands.js
@@ -0,0 +1,89 @@
+const SMART_PASTE_TIMEOUT_MS = 30000;
+
+function getFormFieldOptions(form) {
+  return (form.option("items") || [])
+    .filter((item) => item.dataField)
+    .map((item) => ({
+      dataField: item.dataField,
+      label: item.label?.text ?? item.dataField,
+    }));
+}
+
+function applyFormClearAction(form, formAction) {
+  if (!formAction || formAction.type === "smart_paste") return null;
+
+  if (formAction.type === "clear_all") {
+    try {
+      form.clear();
+      return { status: "success", message: "Cleared all Form fields." };
+    } catch {
+      return {
+        status: "failure",
+        message: "I couldn't clear the form.",
+      };
+    }
+  }
+
+  if (formAction.type === "clear_field") {
+    const isKnownField = getFormFieldOptions(form).some(
+      (f) => f.dataField === formAction.field,
+    );
+
+    if (!isKnownField) {
+      return {
+        status: "failure",
+        message: `I couldn't find a field named "${formAction.field}" to clear.`,
+      };
+    }
+
+    form.updateData(formAction.field, null);
+
+    return { status: "success", message: `Cleared ${formAction.field}.` };
+  }
+
+  return null;
+}
+
+function applyFormSmartPaste(form, text) {
+  return new Promise((resolve) => {
+    let settled = false;
+
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeoutId);
+      form.off("smartPasted", handleSmartPasted);
+      resolve(result);
+    };
+
+    const handleSmartPasted = (e) => {
+      const fieldCount = Object.keys(e.aiResult ?? {}).length;
+      finish(
+        fieldCount > 0
+          ? { status: "success", message: "Updated the form." }
+          : {
+              status: "failure",
+              message: "I couldn't find any Form fields matching the request.",
+            },
+      );
+    };
+
+    const timeoutId = setTimeout(() => {
+      finish({
+        status: "failure",
+        message: "I couldn't process your request. Please try rephrasing it.",
+      });
+    }, SMART_PASTE_TIMEOUT_MS);
+
+    form.on("smartPasted", handleSmartPasted);
+
+    try {
+      form.smartPaste(text);
+    } catch {
+      finish({
+        status: "failure",
+        message: "I couldn't process your request. Please try rephrasing it.",
+      });
+    }
+  });
+}
diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/grid-commands.js b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/grid-commands.js
new file mode 100644
index 000000000000..5005da420a71
--- /dev/null
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/grid-commands.js
@@ -0,0 +1,286 @@
+const gridCommands = {
+  filterValue: {
+    description:
+      "Apply a filter to a single column. Pass column (dataField), operator, and value. " +
+      'Supported operators: "=", "<>", "<", "<=", ">", ">=", "contains", "notcontains", "startswith", "endswith", "anyof". ' +
+      'Date values must be in "YYYY-MM-DDTHH:mm:ss" format (e.g. "2024-05-10T00:00:00"). ' +
+      'The "Completion" column is a boolean (task completed or not): use operator "=" with value true for ' +
+      "completed tasks, or value false for tasks that are not completed. " +
+      "To filter a date column by a year and/or month (the same thing the grid's own header filter does " +
+      'when you pick a year then a month), use operator "anyof" with value as an array of one or more ' +
+      'strings in "YYYY" (whole year, e.g. "2023") or "YYYY/M" (whole month, month is 1-12 with no leading ' +
+      'zero, e.g. "2023/5" for May 2023) format, e.g. {"column": "DueDate", "operator": "anyof", "value": ' +
+      '["2023/5"]} for "May 2023". Only use "anyof" when the year is known; if the year is missing and ' +
+      'cannot be inferred from elsewhere in the request (e.g. plain "in May" with no year anywhere), do ' +
+      "not guess it - omit this action entirely instead of adding it with a made-up year.",
+    schema: {
+      type: "object",
+      properties: {
+        column: { type: "string" },
+        operator: {
+          type: "string",
+          enum: [
+            "=",
+            "<>",
+            "<",
+            "<=",
+            ">",
+            ">=",
+            "contains",
+            "notcontains",
+            "startswith",
+            "endswith",
+            "anyof",
+          ],
+        },
+        value: {
+          anyOf: [
+            { type: ["string", "number", "boolean"] },
+            { type: "array", items: { type: "string" } },
+          ],
+        },
+      },
+      required: ["column", "operator", "value"],
+    },
+    execute(grid, args, rawText) {
+      const { column, failure } = getColumnOrFail(grid, args.column);
+      if (failure) return failure;
+
+      const caption = column.caption ?? args.column;
+      let { value } = args;
+
+      if (args.column === "Completion" && typeof value !== "boolean") {
+        const normalized = String(value).trim().toLowerCase();
+        value =
+          value === 100 ||
+          ["true", "completed", "yes", "100"].includes(normalized);
+      }
+
+      if (
+        (column.dataType === "date" || column.dataType === "datetime") &&
+        typeof value === "string"
+      ) {
+        const parsedDate = new Date(value);
+        if (!Number.isNaN(parsedDate.getTime())) {
+          value = parsedDate;
+        }
+      }
+
+      if (args.operator === "anyof" && Array.isArray(value)) {
+        const mentionedYears = new Set(
+          String(rawText ?? "").match(/\b\d{4}\b/g),
+        );
+        const hasUngroundedYear = value.some(
+          (entry) => !mentionedYears.has(String(entry).split("/")[0]),
+        );
+
+        if (hasUngroundedYear) {
+          return {
+            status: "failure",
+            message: `No field or column exists with such a name, or the entered value is invalid.`,
+          };
+        }
+      }
+
+      try {
+        grid.option("filterValue", [args.column, args.operator, value]);
+        return {
+          status: "success",
+          message: `Filtered by "${caption}".`,
+        };
+      } catch {
+        return {
+          status: "failure",
+          message: `I couldn't apply that filter to "${caption}". Check that the value matches the column's type.`,
+        };
+      }
+    },
+  },
+
+  clearFilter: {
+    description: "Clear all filters on the grid.",
+    schema: { type: "object", properties: {} },
+    execute(grid) {
+      try {
+        grid.clearFilter();
+        return { status: "success", message: "Filter cleared." };
+      } catch {
+        return {
+          status: "failure",
+          message: "I couldn't clear the DataGrid's filters.",
+        };
+      }
+    },
+  },
+
+  sorting: {
+    description:
+      'Sort a column ascending or descending. Pass sortOrder "none" to remove sorting from this column only.',
+    schema: {
+      type: "object",
+      properties: {
+        column: { type: "string" },
+        sortOrder: { type: "string", enum: ["asc", "desc", "none"] },
+      },
+      required: ["column", "sortOrder"],
+    },
+    execute(grid, args) {
+      const { column, failure } = getColumnOrFail(grid, args.column);
+      if (failure) return failure;
+
+      const caption = column.caption ?? args.column;
+
+      try {
+        grid.columnOption(
+          args.column,
+          "sortOrder",
+          args.sortOrder === "none" ? undefined : args.sortOrder,
+        );
+
+        const message =
+          args.sortOrder === "none"
+            ? `Cleared sorting on "${caption}".`
+            : `Sorted by "${caption}" (${args.sortOrder === "asc" ? "ascending" : "descending"}).`;
+
+        return { status: "success", message };
+      } catch {
+        return {
+          status: "failure",
+          message: `I couldn't sort by "${caption}".`,
+        };
+      }
+    },
+  },
+
+  clearSorting: {
+    description: "Remove sorting from all columns.",
+    schema: { type: "object", properties: {} },
+    execute(grid) {
+      try {
+        grid.clearSorting();
+        return { status: "success", message: "Sorting cleared." };
+      } catch {
+        return {
+          status: "failure",
+          message: "I couldn't clear the DataGrid's sorting.",
+        };
+      }
+    },
+  },
+
+  columnsVisibility: {
+    description: "Show or hide a column.",
+    schema: {
+      type: "object",
+      properties: {
+        column: { type: "string" },
+        visible: { type: "boolean" },
+      },
+      required: ["column", "visible"],
+    },
+    execute(grid, args) {
+      const { column, failure } = getColumnOrFail(grid, args.column);
+      if (failure) return failure;
+
+      const caption = column.caption ?? args.column;
+
+      try {
+        grid.columnOption(args.column, "visible", args.visible);
+        return {
+          status: "success",
+          message: args.visible
+            ? `Showed column "${caption}".`
+            : `Hid column "${caption}".`,
+        };
+      } catch {
+        return {
+          status: "failure",
+          message: `I couldn't change the visibility of "${caption}".`,
+        };
+      }
+    },
+  },
+};
+
+function getColumnOrFail(grid, columnName) {
+  const column = grid.columnOption(columnName);
+
+  if (!column) {
+    return {
+      column: null,
+      failure: {
+        status: "failure",
+        message: `I couldn't find a DataGrid column named "${columnName}".`,
+      },
+    };
+  }
+
+  return { column, failure: null };
+}
+
+function buildGridResponseSchema() {
+  const branches = Object.entries(gridCommands).map(([name, cmd]) => ({
+    type: "object",
+    properties: {
+      name: { type: "string", enum: [name] },
+      args: cmd.schema,
+    },
+    required: ["name", "args"],
+  }));
+
+  return {
+    type: "object",
+    properties: {
+      actions: {
+        type: "array",
+        description: "List of grid commands to execute, in order.",
+        items: { anyOf: branches },
+      },
+    },
+    required: ["actions"],
+  };
+}
+
+function buildGridPromptSection(columnNames) {
+  const commandDescriptions = Object.entries(gridCommands)
+    .map(([name, cmd]) => `- "${name}": ${cmd.description}`)
+    .join("\n");
+
+  return [
+    'GRID: translate any part of the request that affects the task grid into one or more grid commands (the "actions" array).',
+    `Available columns (dataField): ${columnNames.join(", ")}.`,
+    "CRITICAL RULE: a column mentioned in the request must clearly correspond to one of the available " +
+      'columns above (matching by meaning is fine, e.g. "due date" -> "DueDate"). If it does not - even ' +
+      "if it superficially looks like it could be a column name - you must NOT invent or substitute the " +
+      "closest-sounding available column. Instead, still emit the action using the column name exactly " +
+      "as written in the request, so the app can report that the column wasn't found - never replace it " +
+      "with a different, existing column just to make the action valid.",
+    'Example: request "filter the ZXQ column by foo" - ZXQ matches no available column, so emit ' +
+      '{"column": "ZXQ", ...} as-is (it will correctly fail as "column not found") - do NOT emit an ' +
+      'action for "Subject" or any other real column instead.',
+    'The "Completion" column is a boolean: true means the task is completed, false means it is not. ' +
+      'To filter for "completed" tasks, use {"column": "Completion", "operator": "=", "value": true}. ' +
+      'To filter for "not completed" tasks, use {"column": "Completion", "operator": "=", "value": false}.',
+    "Available grid commands:",
+    commandDescriptions,
+  ].join("\n");
+}
+
+function getGridColumnNames(gridInstance) {
+  return gridInstance.getVisibleColumns().map((col) => col.dataField);
+}
+
+function applyGridActions(grid, actions, rawText) {
+  return actions.map((action) => {
+    const command = gridCommands[action.name];
+
+    if (!command) {
+      return {
+        status: "failure",
+        message: `I don't know how to do "${action.name}".`,
+      };
+    }
+
+    return command.execute(grid, action.args ?? {}, rawText);
+  });
+}
diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.html b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.html
new file mode 100644
index 000000000000..11eef21e09c0
--- /dev/null
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en">
+  <head>
+    <title>DevExtreme Demo</title>
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=5.0" />
+    <script src="../../../../node_modules/jquery/dist/jquery.min.js"></script>
+    <link rel="stylesheet" type="text/css" href="../../../../node_modules/devextreme-dist/css/dx.light.css" />
+    <script src="../../../../node_modules/devextreme-dist/js/dx.all.js"></script>
+    <script src="../../../../node_modules/devextreme-dist/js/dx.ai-integration.js"></script>
+
+    <script type="module">
+      import { AzureOpenAI } from "https://esm.sh/openai@4.73.1";
+
+      window.AzureOpenAI = AzureOpenAI;
+    </script>
+    <script src="data.js"></script>
+    <script src="grid-commands.js"></script>
+    <script src="form-commands.js"></script>
+    <script src="chat-router.js"></script>
+    <script src="ai-service.js"></script>
+    <script src="index.js"></script>
+
+    <link rel="stylesheet" type="text/css" href="styles.css" />
+  </head>
+  <body class="dx-viewport">
+    <div class="demo-container">
+      <div id="form-container"></div>
+      <div id="toast"></div>
+      <div id="grid-container"></div>
+      <div id="aiAssistantContainer"></div>
+      <div id="ai-fab"></div>
+    </div>
+  </body>
+</html>
diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.js b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.js
new file mode 100644
index 000000000000..7dbefc978170
--- /dev/null
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.js
@@ -0,0 +1,349 @@
+$(function () {
+  DevExpress.config({
+    editorStylingMode: "filled",
+  });
+
+  DevExpress.config({
+    floatingActionButtonConfig: {
+      position: {
+        my: "right bottom",
+        at: "right bottom",
+        of: "#grid-container",
+        offset: "-16 -16",
+      },
+    },
+  });
+
+  DevExpress.localization.loadMessages({
+    en: {
+      "dxChat-textareaPlaceholder": "Enter a prompt...",
+    },
+  });
+
+  let chatInstance;
+  let popupInstance;
+  let clearButtonInstance;
+  let formInstance;
+  let gridInstance;
+  let toastInstance;
+
+  toastInstance = $("#toast")
+    .dxToast({
+      displayTime: 600,
+      closeOnClick: true,
+      message: "Form data is saved.",
+      type: "success",
+      position: {
+        of: "#form-container",
+        at: "bottom center",
+        my: "bottom center",
+        offset: "0 -20",
+      },
+    })
+    .dxToast("instance");
+
+  function pushMessage(message) {
+    chatInstance
+      .getDataSource()
+      .store()
+      .push([
+        {
+          type: "insert",
+          data: {
+            id: Date.now() + Math.random(),
+            timestamp: new Date(),
+            ...message,
+          },
+        },
+      ]);
+  }
+
+  function setDisabled(disabled) {
+    chatInstance.option("disabled", disabled);
+  }
+
+  function updateClearButtonState() {
+    const items = chatInstance.getDataSource().items();
+    clearButtonInstance?.option("disabled", items.length === 0);
+  }
+
+  function clearChat() {
+    const store = chatInstance.getDataSource().store();
+
+    store.clear();
+    chatInstance.getDataSource().reload();
+    updateClearButtonState();
+  }
+
+  function handleUserMessage(message) {
+    setDisabled(true);
+
+    const finish = () => {
+      setDisabled(false);
+      updateClearButtonState();
+    };
+
+    const routed = routeMessage(message.text, {
+      form: formInstance,
+      gridInstance,
+      aiIntegration,
+      pushMessage,
+    });
+
+    routed.finally(finish);
+  }
+
+  popupInstance = $("#aiAssistantContainer")
+    .dxPopup({
+      title: "AI Assistant",
+      width: 400,
+      height: "90%",
+      dragEnabled: true,
+      resizeEnabled: true,
+      showCloseButton: true,
+      shading: false,
+      visible: false,
+      onHiding() {
+        fabBtn.option("visible", true);
+      },
+      onShowing() {
+        fabBtn.option("visible", false);
+      },
+      position: {
+        my: "right top",
+        at: "right top",
+        of: ".demo-container",
+        offset: "-20 20",
+      },
+      toolbarItems: [
+        {
+          widget: "dxButton",
+          toolbar: "top",
+          location: "after",
+          cssClass: CLASSES.clearChatButton,
+          options: {
+            icon: "clearhistory",
+            disabled: true,
+            hint: "Clear chat",
+            onClick: () => clearChat(),
+            onInitialized: (e) => {
+              clearButtonInstance = e.component;
+            },
+          },
+        },
+      ],
+      contentTemplate($container) {
+        const $chatContainer = $("<div>")
+          .addClass("ai-chat-content")
+          .appendTo($container);
+
+        $chatContainer.dxChat({
+          height: "100%",
+          showAvatar: false,
+          width: "auto",
+          dataSource: {
+            store: new DevExpress.data.ArrayStore({ key: "id" }),
+          },
+          reloadOnChange: true,
+          user: { id: "user" },
+          showUserName: false,
+          speechToTextEnabled: true,
+          suggestions: {
+            items: [
+              { text: "Show Completed Tasks", prompt: "Show Completed Tasks" },
+              {
+                text: "Change State to Texas",
+                prompt: "Change State to Texas",
+              },
+            ],
+            onItemClick(e) {
+              const { prompt } = e.itemData;
+              const message = {
+                id: Date.now() + Math.random(),
+                timestamp: new Date(),
+                author: { id: "user" },
+                text: prompt,
+              };
+
+              pushMessage(message);
+              handleUserMessage(message);
+            },
+          },
+          emptyViewTemplate(_data, container) {
+            const $icon = $("<div>").addClass(
+              "dx-chat-messagelist-empty-image dx-ai-chat__empty-image",
+            );
+            const $message = $("<div>")
+              .addClass("ai-chat-empty-message")
+              .text(emptyViewMessage);
+            const $prompt = $("<div>")
+              .addClass("ai-chat-empty-prompt")
+              .html(emptyViewPrompt);
+
+            $(container).append($icon).append($message).append($prompt);
+          },
+          onMessageEntered(e) {
+            handleUserMessage(e.message);
+          },
+          onInitialized(e) {
+            chatInstance = e.component;
+          },
+        });
+      },
+    })
+    .dxPopup("instance");
+
+  const aiIntegration = createAiIntegration();
+
+  formInstance = $("#form-container")
+    .dxForm({
+      formData: employee,
+      colCount: 3,
+      labelLocation: "top",
+      onOptionChanged: (e) => {
+        if (e.name === "isDirty") {
+          const saveButton = formInstance.getButton("Save");
+          saveButton.option("disabled", !e.value);
+        }
+      },
+      aiIntegration,
+      items: [
+        {
+          dataField: "Prefix",
+          label: { text: "Title" },
+          editorType: "dxSelectBox",
+          editorOptions: { items: titles, searchEnabled: true },
+          aiOptions: {
+            instruction:
+              "Only fill this field with one of the allowed values (Mr., Mrs., Ms.) if a " +
+              "title is explicitly mentioned in the text. Never use this field for any part " +
+              "of a person's name.",
+          },
+        },
+        {
+          dataField: "FirstName",
+          label: { text: "First Name" },
+          aiOptions: {
+            instruction:
+              "Only fill this field if the text clearly refers to a person's given name. " +
+              "Never use grid/task-related words like Subject, Priority, Status, Due Date, " +
+              "Completion, or generic verbs like sort/filter/show as a name.",
+          },
+        },
+        {
+          dataField: "LastName",
+          label: { text: "Last Name" },
+          aiOptions: {
+            instruction:
+              "If the text gives a full person name (e.g. 'customer name', 'employee name') " +
+              "without separately labeled first/last names, use only the first word as First " +
+              "Name and the rest of the name as Last Name.",
+          },
+        },
+        {
+          dataField: "Position",
+          editorType: "dxSelectBox",
+          editorOptions: { items: positions, searchEnabled: true },
+          aiOptions: {
+            instruction:
+              "Only fill this field with one of the allowed job position values if the text " +
+              "explicitly refers to the employee's own job title/role.",
+          },
+        },
+        {
+          dataField: "State",
+          editorType: "dxSelectBox",
+          editorOptions: { items: states, searchEnabled: true },
+          aiOptions: {
+            instruction:
+              "Only fill this field with one of the allowed US state values if the text " +
+              "explicitly refers to the employee's home/office state",
+          },
+        },
+        {
+          dataField: "BirthDate",
+          editorType: "dxDateBox",
+          editorOptions: { displayFormat: "M/d/yyyy" },
+          aiOptions: {
+            instruction:
+              "Only fill this field if the text explicitly refers to the employee's own birth " +
+              "date or date of birth.",
+          },
+        },
+        {
+          itemType: "button",
+          name: "Save",
+          colSpan: 3,
+          cssClass: "save-button",
+          buttonOptions: {
+            text: "Save",
+            type: "default",
+            disabled: true,
+            useSubmitBehavior: true,
+            width: "120px",
+            onClick: () => {
+              toastInstance.show();
+            },
+          },
+        },
+      ],
+    })
+    .dxForm("instance");
+
+  gridInstance = $("#grid-container")
+    .dxDataGrid({
+      dataSource: tasks,
+      keyExpr: "ID",
+      showBorders: true,
+      filterRow: { visible: true },
+      headerFilter: { visible: true },
+      filterSyncEnabled: true,
+      columns: [
+        { dataField: "Subject", width: 250 },
+        { dataField: "StartDate", dataType: "date" },
+        { dataField: "DueDate", dataType: "date" },
+        {
+          dataField: "Priority",
+          caption: "Priority",
+          cellTemplate: (container, options) => {
+            $("<div>")
+              .css({
+                background: colors[options.value],
+                borderRadius: "24px",
+                padding: "2px 8px",
+                display: "inline-block",
+                textAlign: "center",
+              })
+              .text(options.value)
+              .appendTo(container);
+          },
+        },
+        {
+          dataField: "Completion",
+          caption: "Completed",
+          alignment: "center",
+          dataType: "boolean",
+          calculateCellValue: (rowData) => rowData.Completion === 100,
+          calculateFilterExpression(filterValue, selectedFilterOperation) {
+            const wantsCompleted =
+              selectedFilterOperation === "<>" ? !filterValue : !!filterValue;
+            const rawCompletion = (rowData) => rowData.Completion;
+            return wantsCompleted
+              ? [rawCompletion, "=", 100]
+              : [rawCompletion, "<", 100];
+          },
+        },
+      ],
+    })
+    .dxDataGrid("instance");
+
+  let fabBtn = $("#ai-fab")
+    .dxSpeedDialAction({
+      icon: "sparkle",
+      label: "AI Assistant",
+      onClick: function (e) {
+        popupInstance.toggle();
+      },
+    })
+    .dxSpeedDialAction("instance");
+});
diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/styles.css b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/styles.css
new file mode 100644
index 000000000000..2031731a987e
--- /dev/null
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/styles.css
@@ -0,0 +1,68 @@
+.dx-chat {
+  max-width: 900px;
+  border-radius: 0;
+  min-height: 20em;
+}
+
+#grid-container {
+  margin-top: 20px;
+  min-height: 360px;
+}
+
+#form-container {
+  border: 1px solid #e0e0e0;
+  padding: 16px;
+}
+
+.dx-color-scheme-blue-light #form-container {
+  background-color: #fff;
+}
+
+.demo-container {
+  margin: 20px;
+  height: 556px;
+}
+
+.ai-chat-empty-icon {
+  font-size: 32px;
+  color: #337ab7;
+  text-align: center;
+  margin-bottom: 12px;
+}
+
+.ai-chat-empty-message {
+  font-size: 18px;
+  font-weight: 400;
+  text-align: center;
+  color: #242424;
+  margin-bottom: 8px;
+}
+
+.ai-chat-empty-prompt {
+  font-size: 14px;
+  color: #888;
+  text-align: center;
+  padding: 0 24px;
+  white-space: pre-line;
+}
+
+.ai-chat-clear-button {
+  margin-right: 8px;
+}
+
+.dx-popup-content {
+  padding: 0;
+}
+
+.dx-chat-messagebox {
+  border-top-color: transparent;
+}
+
+.dx-chat-messagelist-empty-view,
+.dx-chat-messagebox {
+  padding-top: 0;
+}
+
+.dx-layout-manager .dx-field-item.save-button {
+  padding-bottom: 0;
+}
diff --git a/apps/demos/menuMeta.json b/apps/demos/menuMeta.json
index 72e77fc3bcc3..4e910a8cc810 100644
--- a/apps/demos/menuMeta.json
+++ b/apps/demos/menuMeta.json
@@ -139,6 +139,21 @@
                 "DemoType": "Web"
               }
             ]
+          },
+          {
+            "Name": "Custom AI Assistant",
+            "Equivalents": "AI, Chatbot, Assistant",
+            "Demos": [
+              {
+                "Title": "Custom AI Assistant",
+                "Name": "CustomAIAssistant",
+                "Widget": "Chat",
+                "Badge": "AI",
+                "TopLevel": true,
+                "Modules": "openai",
+                "DemoType": "Web"
+              }
+            ]
           }
         ]
       },
@@ -4444,6 +4459,20 @@
               }
             ]
           },
+          {
+            "Name": "Custom AI Assistant",
+            "Equivalents": "AI, Chatbot, Assistant",
+            "Demos": [
+              {
+                "Title": "Custom AI Assistant",
+                "Name": "CustomAIAssistant",
+                "Widget": "Chat",
+                "Badge": "AI",
+                "Modules": "openai",
+                "DemoType": "Web"
+              }
+            ]
+          },
           {
             "Name": "AI and Chatbot Integration",
             "Equivalents": "AI, Chatbot, Assistant",

From c77a2dd3f266dd210325c92536c9adffd4bd0a26 Mon Sep 17 00:00:00 2001
From: Diana Gromova <16adianay@gmail.com>
Date: Thu, 3 Sep 2026 16:32:29 +0400
Subject: [PATCH 2/7] Fixed failed tests

- Add aria-label to CheckBoxes
- Add etalons
- Fux quotes
---
 .../CustomAIAssistant/jQuery/ai-service.js    |  14 +-
 .../CustomAIAssistant/jQuery/chat-router.js   | 110 +++++------
 .../Chat/CustomAIAssistant/jQuery/data.js     |  94 +++++-----
 .../CustomAIAssistant/jQuery/form-commands.js |  30 +--
 .../CustomAIAssistant/jQuery/grid-commands.js |  78 ++++----
 .../Chat/CustomAIAssistant/jQuery/index.html  |   2 +-
 .../Chat/CustomAIAssistant/jQuery/index.js    | 171 +++++++++---------
 apps/demos/eslint.config.mjs                  |  12 ++
 ...-CustomAIAssistant (fluent.blue.light).png | Bin 0 -> 70581 bytes
 ...ustomAIAssistant (material.blue.light).png | Bin 0 -> 68270 bytes
 10 files changed, 264 insertions(+), 247 deletions(-)
 create mode 100644 apps/demos/testing/etalons/Chat-CustomAIAssistant (fluent.blue.light).png
 create mode 100644 apps/demos/testing/etalons/Chat-CustomAIAssistant (material.blue.light).png

diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/ai-service.js b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/ai-service.js
index 844db2d9c648..5571107b6ff5 100644
--- a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/ai-service.js
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/ai-service.js
@@ -24,15 +24,15 @@ function createAiIntegration() {
 
   async function getAIResponseRecursive(messages, signal) {
     return getAIResponse(messages, signal).catch(async (error) => {
-      if (!error.message.includes("Connection error")) {
+      if (!error.message.includes('Connection error')) {
         throw error;
       }
 
       DevExpress.ui.notify({
         message:
-          "Our demo AI service reached a temporary request limit. Retrying in 30 seconds.",
-        width: "auto",
-        type: "error",
+          'Our demo AI service reached a temporary request limit. Retrying in 30 seconds.',
+        width: 'auto',
+        type: 'error',
         displayTime: 5000,
       });
 
@@ -49,7 +49,7 @@ function createAiIntegration() {
         return {
           promise: Promise.reject(
             new ChatCommandError(
-              "❌ This message is too long for me to process. Please shorten it and try again.",
+              '❌ This message is too long for me to process. Please shorten it and try again.',
             ),
           ),
           abort: () => {},
@@ -60,8 +60,8 @@ function createAiIntegration() {
 
       const isSmartPasteRequest = Array.isArray(data?.fields);
       const system = isSmartPasteRequest
-        ? `${prompt.system ?? ""} IMPORTANT: reply on a SINGLE line with no line breaks of any kind - use ";;;" as the only separator between fields.`
-        : (prompt.system ?? "");
+        ? `${prompt.system ?? ''} IMPORTANT: reply on a SINGLE line with no line breaks of any kind - use ';;;' as the only separator between fields.`
+        : (prompt.system ?? '');
 
       const aiPrompt = [
         { role: "system", content: system },
diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/chat-router.js b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/chat-router.js
index 0a6fde992ad8..958e0ff849a7 100644
--- a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/chat-router.js
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/chat-router.js
@@ -7,7 +7,7 @@ function extractJson(text) {
     return JSON.parse(match[0]);
   } catch {
     throw new ChatCommandError(
-      "❌ I received an unexpected response from the AI service. Please rephrase your request and try again.",
+      '❌ I received an unexpected response from the AI service. Please rephrase your request and try again.',
     );
   }
 }
@@ -32,71 +32,71 @@ function executeAiCommand(text, aiIntegration) {
 
 function buildGridSystemPrompt(columnNames) {
   return [
-    "You control a task DataGrid on this page.",
-    "This page ALSO has a separate employee/customer profile form (fields like name, title/prefix, " +
-      "position, state, birth date) that is handled elsewhere - it is NOT part of this grid.",
-    "Figure out what the user's request is about and translate ONLY the part that is clearly about " +
-      "the task grid into the matching commands described below.",
-    "Do NOT create a grid action just because a value could technically fit a text column (e.g. " +
-      '"Subject"). If the request is about the profile form (e.g. mentions a person\'s name, title, ' +
-      'job position, state, or birth date), leave that part out of "actions" entirely - even if no ' +
-      "other part of the request is grid-related.",
-    "",
+    'You control a task DataGrid on this page.',
+    'This page ALSO has a separate employee/customer profile form (fields like name, title/prefix, ' +
+      'position, state, birth date) that is handled elsewhere - it is NOT part of this grid.',
+    'Figure out what the user\'s request is about and translate ONLY the part that is clearly about ' +
+      'the task grid into the matching commands described below.',
+    'Do NOT create a grid action just because a value could technically fit a text column (e.g. ' +
+      "'Subject'). If the request is about the profile form (e.g. mentions a person's name, title, " +
+      "job position, state, or birth date), leave that part out of 'actions' entirely - even if no " +
+      'other part of the request is grid-related.',
+    '',
     buildGridPromptSection(columnNames),
-    "",
-    "Respond with STRICT JSON only, no code fences, no explanations, matching this schema:",
+    '',
+    'Respond with STRICT JSON only, no code fences, no explanations, matching this schema:',
     JSON.stringify(buildGridResponseSchema()),
-    "",
-    'If the request has nothing to do with the grid, respond with "actions": [].',
-  ].join("\n");
+    '',
+    "If the request has nothing to do with the grid, respond with 'actions': [].",
+  ].join('\n');
 }
 
 const FIELD_OR_VALUE_NOT_FOUND_MESSAGE =
-  "❌ No field or column exists with such a name, or the entered value is invalid. Please check the name and value and try again.";
+  '❌ No field or column exists with such a name, or the entered value is invalid. Please check the name and value and try again.';
 
 const MAX_USER_MESSAGE_LENGTH = 2000;
-const ROUTER_TARGETS = new Set(["form", "grid", "mixed", "none"]);
-const FORM_ACTION_TYPES = new Set(["clear_field", "clear_all", "smart_paste"]);
+const ROUTER_TARGETS = new Set(['form', 'grid', 'mixed', 'none']);
+const FORM_ACTION_TYPES = new Set(['clear_field', 'clear_all', 'smart_paste']);
 
 function buildFormActionPromptSection(form) {
   const fieldList = getFormFieldOptions(form)
     .map((f) => `${f.dataField} (${f.label})`)
-    .join(", ");
+    .join(', ');
 
   return [
     `Form fields (dataField and label): ${fieldList}.`,
-    'If the request is about the form, also set "formAction" to one of:',
-    '- {"type": "clear_field", "field": "<dataField>"} to clear one specific field.',
-    '- {"type": "clear_all"} to clear/reset the whole form.',
-    '- {"type": "smart_paste"} to fill in form data from the request text.',
-    'Set "formAction" to null if the request is not about the form.',
-  ].join("\n");
+    "If the request is about the form, also set 'formAction' to one of:",
+    "- {'type': 'clear_field', 'field': '<dataField>'} to clear one specific field.",
+    "- {'type': 'clear_all'} to clear/reset the whole form.",
+    "- {'type': 'smart_paste'} to fill in form data from the request text.",
+    "Set 'formAction' to null if the request is not about the form.",
+  ].join('\n');
 }
 
 async function classifyRequest(text, aiIntegration, form) {
   if (!aiIntegration) {
-    return { target: "mixed", formAction: null };
+    return { target: 'mixed', formAction: null };
   }
 
   const prompt = [
-    "Decide which UI area should handle the user's request.",
-    "Return STRICT JSON only, without markdown fences.",
-    'Format: {"target": "form" | "grid" | "mixed" | "none", "formAction": <see below> | null, "reason": "short explanation" }',
-    "Rules:",
-    "- Use form for profile/customer form updates, field clearing, or smart-paste style data entry.",
-    "- Use grid for sorting, filtering, showing/hiding columns, or other DataGrid tasks.",
-    "- Use mixed when the request clearly asks for both a form change and a grid change together.",
-    "- Use none when the request is unrelated to both areas.",
-    "If you are not confident, return mixed.",
-    "",
+    'Decide which UI area should handle the user\'s request.',
+    'Return STRICT JSON only, without markdown fences.',
+    "Format: {'target': 'form' | 'grid' | 'mixed' | 'none', 'formAction': <see below> | null, 'reason': 'short explanation' }",
+    'Rules:',
+    '- Use form for profile/customer form updates, field clearing, or smart-paste style data entry.',
+    '- Use grid for sorting, filtering, showing/hiding columns, or other DataGrid tasks.',
+    '- Use mixed when the request clearly asks for both a form change and a grid change together.',
+    '- Use none when the request is unrelated to both areas.',
+    'If you are not confident, return mixed.',
+    '',
     buildFormActionPromptSection(form),
-    "",
-    `User request: "${text}"`,
-  ].join("\n");
+    '',
+    `User request: '${text}'`,
+  ].join('\n');
 
   try {
     const parsed = await executeAiCommand(prompt, aiIntegration);
-    const target = String(parsed?.target ?? "mixed")
+    const target = String(parsed?.target ?? 'mixed')
       .trim()
       .toLowerCase();
     const rawFormAction = parsed?.formAction;
@@ -106,17 +106,17 @@ async function classifyRequest(text, aiIntegration, form) {
         : null;
 
     return {
-      target: ROUTER_TARGETS.has(target) ? target : "mixed",
+      target: ROUTER_TARGETS.has(target) ? target : 'mixed',
       formAction,
     };
   } catch {
-    return { target: "mixed", formAction: null };
+    return { target: 'mixed', formAction: null };
   }
 }
 
 function buildGridResultsPromise(gridInstance, aiIntegration, text) {
   const columnNames = getGridColumnNames(gridInstance);
-  const prompt = `${buildGridSystemPrompt(columnNames)}\n\nUser request: "${text}"`;
+  const prompt = `${buildGridSystemPrompt(columnNames)}\n\nUser request: '${text}'`;
 
   return executeAiCommand(prompt, aiIntegration)
     .then((parsed) => {
@@ -155,19 +155,19 @@ function buildFormResultsPromise(form, formAction, text) {
 }
 
 function formatFailures(failed) {
-  return failed.map((message) => `❌ ${message}`).join("\n");
+  return failed.map((message) => `❌ ${message}`).join('\n');
 }
 
 function formatSucceeded(succeeded) {
-  return succeeded.map((message) => `✅ Done. ${message}`).join("\n");
+  return succeeded.map((message) => `✅ Done. ${message}`).join('\n');
 }
 
 function joinSucceededOrThrow(results, fallbackError) {
   const succeeded = results
-    .filter((r) => r.status === "success")
+    .filter((r) => r.status === 'success')
     .map((r) => r.message);
   const failed = results
-    .filter((r) => r.status === "failure")
+    .filter((r) => r.status === 'failure')
     .map((r) => r.message);
 
   if (succeeded.length === 0) {
@@ -185,7 +185,7 @@ async function runCommand(text, { form, gridInstance, aiIntegration }) {
   if (text.length > MAX_USER_MESSAGE_LENGTH) {
     return Promise.reject(
       new ChatCommandError(
-        "❌ This message is too long for me to process. Please shorten it and try again.",
+        '❌ This message is too long for me to process. Please shorten it and try again.',
       ),
     );
   }
@@ -196,14 +196,14 @@ async function runCommand(text, { form, gridInstance, aiIntegration }) {
     form,
   );
 
-  if (target === "form") {
+  if (target === 'form') {
     const { results: formResults, error: formError } =
       await buildFormResultsPromise(form, formAction, text);
 
     return joinSucceededOrThrow(formResults, formError);
   }
 
-  if (target === "grid") {
+  if (target === 'grid') {
     gridInstance?.beginCustomLoading();
 
     const { results: gridResults, error: gridError } =
@@ -222,14 +222,14 @@ async function runCommand(text, { form, gridInstance, aiIntegration }) {
 
   if (gridError) {
     console.warn(
-      "DataGrid AI request failed, but the Form request may have succeeded:",
+      'DataGrid AI request failed, but the Form request may have succeeded:',
       gridError,
     );
   }
 
   if (formError) {
     console.warn(
-      "Form AI request failed, but the DataGrid request may have succeeded:",
+      'Form AI request failed, but the DataGrid request may have succeeded:',
       formError,
     );
   }
@@ -244,7 +244,7 @@ function reportAiResult(promise, pushMessage) {
   return promise
     .then((message) => {
       pushMessage({
-        author: { id: "ai", name: "AI Assistant" },
+        author: { id: 'ai', name: 'AI Assistant' },
         text: message,
       });
     })
@@ -252,7 +252,7 @@ function reportAiResult(promise, pushMessage) {
       const text =
         error instanceof ChatCommandError
           ? error.message
-          : "❌ I couldn't reach the AI service. Please check your connection and try again.";
+          : '❌ I couldn\'t reach the AI service. Please check your connection and try again.';
 
       pushMessage({
         author: { id: "ai", name: "AI Assistant" },
diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/data.js b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/data.js
index bc5c56febde6..c0a181887d6f 100644
--- a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/data.js
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/data.js
@@ -1,86 +1,86 @@
 const CLASSES = {
-  clearChatButton: "ai-chat-clear-button",
+  clearChatButton: 'ai-chat-clear-button',
 };
 
-const deployment = "demo-mini";
-const apiVersion = "2024-02-01";
-const endpoint = "https://public-api.devexpress.com/demo-openai";
-const apiKey = "DEMO";
+const deployment = 'demo-mini';
+const apiVersion = '2024-02-01';
+const endpoint = 'https://public-api.devexpress.com/demo-openai';
+const apiKey = 'DEMO';
 
-const emptyViewMessage = "How can I help with this page?";
+const emptyViewMessage = 'How can I help with this page?';
 const emptyViewPrompt =
-  "Update employee <b>Form</b> fields.\nFilter or sort tasks, display or hide <b>DataGrid</b> columns, or clear all filters and sorting."
+  'Update employee <b>Form</b> fields.\nFilter or sort tasks, display or hide <b>DataGrid</b> columns, or clear all filters and sorting.';
 
-const titles = ["Mr.", "Mrs.", "Ms."];
-const colors = { High: "#F1BBBC", Normal: "#F9E2AE", Low: "#9FD89F" };
-const states = ["California", "New York", "Texas"];
+const titles = ['Mr.', 'Mrs.', 'Ms.'];
+const colors = { High: '#F1BBBC', Normal: '#F9E2AE', Low: '#9FD89F' };
+const states = ['California', 'New York', 'Texas'];
 const positions = [
-  "CEO",
-  "Sales Assistant",
-  "CMO",
-  "Manager",
-  "Designer",
-  "Developer",
+  'CEO',
+  'Sales Assistant',
+  'CMO',
+  'Manager',
+  'Designer',
+  'Developer',
 ];
 
 const employee = {
   ID: 1,
-  Prefix: "Mr.",
-  FirstName: "John",
-  LastName: "Heart",
-  Position: "CEO",
-  State: "California",
-  BirthDate: "1964/03/16",
+  Prefix: 'Mr.',
+  FirstName: 'John',
+  LastName: 'Heart',
+  Position: 'CEO',
+  State: 'California',
+  BirthDate: '1964/03/16',
 };
 
 const tasks = [
   {
     ID: 5,
-    Subject: "Choose between PPO and HMO Health Plan",
-    StartDate: "2026/02/15",
-    DueDate: "2026/04/15",
-    Status: "In Progress",
-    Priority: "Low",
+    Subject: 'Choose between PPO and HMO Health Plan',
+    StartDate: '2026/02/15',
+    DueDate: '2026/04/15',
+    Status: 'In Progress',
+    Priority: 'Low',
     Completion: 75,
     EmployeeID: 1,
   },
   {
     ID: 6,
-    Subject: "Google AdWords Strategy",
-    StartDate: "2026/02/16",
-    DueDate: "2026/02/28",
-    Status: "Completed",
-    Priority: "High",
+    Subject: 'Google AdWords Strategy',
+    StartDate: '2026/02/16',
+    DueDate: '2026/02/28',
+    Status: 'Completed',
+    Priority: 'High',
     Completion: 100,
     EmployeeID: 1,
   },
   {
     ID: 7,
-    Subject: "New Brochures",
-    StartDate: "2026/02/17",
-    DueDate: "2026/02/24",
-    Status: "Completed",
-    Priority: "Normal",
+    Subject: 'New Brochures',
+    StartDate: '2026/02/17',
+    DueDate: '2026/02/24',
+    Status: 'Completed',
+    Priority: 'Normal',
     Completion: 100,
     EmployeeID: 1,
   },
   {
     ID: 22,
-    Subject: "Update NDA Agreement",
-    StartDate: "2026/03/14",
-    DueDate: "2026/03/16",
-    Status: "Completed",
-    Priority: "High",
+    Subject: 'Update NDA Agreement',
+    StartDate: '2026/03/14',
+    DueDate: '2026/03/16',
+    Status: 'Completed',
+    Priority: 'High',
     Completion: 100,
     EmployeeID: 1,
   },
   {
     ID: 52,
-    Subject: "Review Product Recall Report by Engineering Team",
-    StartDate: "2026/05/17",
-    DueDate: "2026/05/20",
-    Status: "Completed",
-    Priority: "High",
+    Subject: 'Review Product Recall Report by Engineering Team',
+    StartDate: '2026/05/17',
+    DueDate: '2026/05/20',
+    Status: 'Completed',
+    Priority: 'High',
     Completion: 100,
     EmployeeID: 1,
   },
diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/form-commands.js b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/form-commands.js
index 9be2a171b732..4d7e58ce75f9 100644
--- a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/form-commands.js
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/form-commands.js
@@ -1,7 +1,7 @@
 const SMART_PASTE_TIMEOUT_MS = 30000;
 
 function getFormFieldOptions(form) {
-  return (form.option("items") || [])
+  return (form.option('items') || [])
     .filter((item) => item.dataField)
     .map((item) => ({
       dataField: item.dataField,
@@ -10,35 +10,35 @@ function getFormFieldOptions(form) {
 }
 
 function applyFormClearAction(form, formAction) {
-  if (!formAction || formAction.type === "smart_paste") return null;
+  if (!formAction || formAction.type === 'smart_paste') return null;
 
-  if (formAction.type === "clear_all") {
+  if (formAction.type === 'clear_all') {
     try {
       form.clear();
-      return { status: "success", message: "Cleared all Form fields." };
+      return { status: 'success', message: 'Cleared all Form fields.' };
     } catch {
       return {
-        status: "failure",
+        status: 'failure',
         message: "I couldn't clear the form.",
       };
     }
   }
 
-  if (formAction.type === "clear_field") {
+  if (formAction.type === 'clear_field') {
     const isKnownField = getFormFieldOptions(form).some(
       (f) => f.dataField === formAction.field,
     );
 
     if (!isKnownField) {
       return {
-        status: "failure",
-        message: `I couldn't find a field named "${formAction.field}" to clear.`,
+        status: 'failure',
+        message: `I couldn't find a field named '${formAction.field}' to clear.`,
       };
     }
 
     form.updateData(formAction.field, null);
 
-    return { status: "success", message: `Cleared ${formAction.field}.` };
+    return { status: 'success', message: `Cleared ${formAction.field}.` };
   }
 
   return null;
@@ -52,7 +52,7 @@ function applyFormSmartPaste(form, text) {
       if (settled) return;
       settled = true;
       clearTimeout(timeoutId);
-      form.off("smartPasted", handleSmartPasted);
+      form.off('smartPasted', handleSmartPasted);
       resolve(result);
     };
 
@@ -60,9 +60,9 @@ function applyFormSmartPaste(form, text) {
       const fieldCount = Object.keys(e.aiResult ?? {}).length;
       finish(
         fieldCount > 0
-          ? { status: "success", message: "Updated the form." }
+            ? { status: 'success', message: 'Updated the form.' }
           : {
-              status: "failure",
+              status: 'failure',
               message: "I couldn't find any Form fields matching the request.",
             },
       );
@@ -70,18 +70,18 @@ function applyFormSmartPaste(form, text) {
 
     const timeoutId = setTimeout(() => {
       finish({
-        status: "failure",
+        status: 'failure',
         message: "I couldn't process your request. Please try rephrasing it.",
       });
     }, SMART_PASTE_TIMEOUT_MS);
 
-    form.on("smartPasted", handleSmartPasted);
+    form.on('smartPasted', handleSmartPasted);
 
     try {
       form.smartPaste(text);
     } catch {
       finish({
-        status: "failure",
+        status: 'failure',
         message: "I couldn't process your request. Please try rephrasing it.",
       });
     }
diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/grid-commands.js b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/grid-commands.js
index 5005da420a71..08b74e4e24e7 100644
--- a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/grid-commands.js
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/grid-commands.js
@@ -1,18 +1,18 @@
 const gridCommands = {
   filterValue: {
     description:
-      "Apply a filter to a single column. Pass column (dataField), operator, and value. " +
+      'Apply a filter to a single column. Pass column (dataField), operator, and value. ' +
       'Supported operators: "=", "<>", "<", "<=", ">", ">=", "contains", "notcontains", "startswith", "endswith", "anyof". ' +
       'Date values must be in "YYYY-MM-DDTHH:mm:ss" format (e.g. "2024-05-10T00:00:00"). ' +
       'The "Completion" column is a boolean (task completed or not): use operator "=" with value true for ' +
-      "completed tasks, or value false for tasks that are not completed. " +
+      'completed tasks, or value false for tasks that are not completed. ' +
       "To filter a date column by a year and/or month (the same thing the grid's own header filter does " +
       'when you pick a year then a month), use operator "anyof" with value as an array of one or more ' +
       'strings in "YYYY" (whole year, e.g. "2023") or "YYYY/M" (whole month, month is 1-12 with no leading ' +
       'zero, e.g. "2023/5" for May 2023) format, e.g. {"column": "DueDate", "operator": "anyof", "value": ' +
       '["2023/5"]} for "May 2023". Only use "anyof" when the year is known; if the year is missing and ' +
       'cannot be inferred from elsewhere in the request (e.g. plain "in May" with no year anywhere), do ' +
-      "not guess it - omit this action entirely instead of adding it with a made-up year.",
+      'not guess it - omit this action entirely instead of adding it with a made-up year.',
     schema: {
       type: "object",
       properties: {
@@ -49,16 +49,16 @@ const gridCommands = {
       const caption = column.caption ?? args.column;
       let { value } = args;
 
-      if (args.column === "Completion" && typeof value !== "boolean") {
+      if (args.column === 'Completion' && typeof value !== 'boolean') {
         const normalized = String(value).trim().toLowerCase();
         value =
           value === 100 ||
-          ["true", "completed", "yes", "100"].includes(normalized);
+          ['true', 'completed', 'yes', '100'].includes(normalized);
       }
 
       if (
-        (column.dataType === "date" || column.dataType === "datetime") &&
-        typeof value === "string"
+        (column.dataType === 'date' || column.dataType === 'datetime') &&
+        typeof value === 'string'
       ) {
         const parsedDate = new Date(value);
         if (!Number.isNaN(parsedDate.getTime())) {
@@ -66,7 +66,7 @@ const gridCommands = {
         }
       }
 
-      if (args.operator === "anyof" && Array.isArray(value)) {
+      if (args.operator === 'anyof' && Array.isArray(value)) {
         const mentionedYears = new Set(
           String(rawText ?? "").match(/\b\d{4}\b/g),
         );
@@ -76,22 +76,22 @@ const gridCommands = {
 
         if (hasUngroundedYear) {
           return {
-            status: "failure",
-            message: `No field or column exists with such a name, or the entered value is invalid.`,
+            status: 'failure',
+            message: 'No field or column exists with such a name, or the entered value is invalid.',
           };
         }
       }
 
       try {
-        grid.option("filterValue", [args.column, args.operator, value]);
+        grid.option('filterValue', [args.column, args.operator, value]);
         return {
-          status: "success",
-          message: `Filtered by "${caption}".`,
+          status: 'success',
+          message: `Filtered by '${caption}'.`,
         };
       } catch {
         return {
-          status: "failure",
-          message: `I couldn't apply that filter to "${caption}". Check that the value matches the column's type.`,
+          status: 'failure',
+          message: `I couldn't apply that filter to '${caption}'. Check that the value matches the column's type.`,
         };
       }
     },
@@ -103,10 +103,10 @@ const gridCommands = {
     execute(grid) {
       try {
         grid.clearFilter();
-        return { status: "success", message: "Filter cleared." };
+        return { status: 'success', message: 'Filter cleared.' };
       } catch {
         return {
-          status: "failure",
+          status: 'failure',
           message: "I couldn't clear the DataGrid's filters.",
         };
       }
@@ -133,20 +133,20 @@ const gridCommands = {
       try {
         grid.columnOption(
           args.column,
-          "sortOrder",
-          args.sortOrder === "none" ? undefined : args.sortOrder,
+          'sortOrder',
+          args.sortOrder === 'none' ? undefined : args.sortOrder,
         );
 
         const message =
-          args.sortOrder === "none"
-            ? `Cleared sorting on "${caption}".`
-            : `Sorted by "${caption}" (${args.sortOrder === "asc" ? "ascending" : "descending"}).`;
+          args.sortOrder === 'none'
+            ? `Cleared sorting on '${caption}'.`
+            : `Sorted by '${caption}' (${args.sortOrder === 'asc' ? 'ascending' : 'descending'}).`;
 
         return { status: "success", message };
       } catch {
         return {
           status: "failure",
-          message: `I couldn't sort by "${caption}".`,
+          message: `I couldn't sort by '${caption}'.`,
         };
       }
     },
@@ -158,10 +158,10 @@ const gridCommands = {
     execute(grid) {
       try {
         grid.clearSorting();
-        return { status: "success", message: "Sorting cleared." };
+        return { status: 'success', message: 'Sorting cleared.' };
       } catch {
         return {
-          status: "failure",
+          status: 'failure',
           message: "I couldn't clear the DataGrid's sorting.",
         };
       }
@@ -187,15 +187,15 @@ const gridCommands = {
       try {
         grid.columnOption(args.column, "visible", args.visible);
         return {
-          status: "success",
+          status: 'success',
           message: args.visible
-            ? `Showed column "${caption}".`
-            : `Hid column "${caption}".`,
+            ? `Showed column '${caption}'.`
+            : `Hid column '${caption}'.`,
         };
       } catch {
         return {
-          status: "failure",
-          message: `I couldn't change the visibility of "${caption}".`,
+          status: 'failure',
+          message: `I couldn't change the visibility of '${caption}'.`,
         };
       }
     },
@@ -209,8 +209,8 @@ function getColumnOrFail(grid, columnName) {
     return {
       column: null,
       failure: {
-        status: "failure",
-        message: `I couldn't find a DataGrid column named "${columnName}".`,
+        status: 'failure',
+        message: `I couldn't find a DataGrid column named '${columnName}'.`,
       },
     };
   }
@@ -243,12 +243,12 @@ function buildGridResponseSchema() {
 
 function buildGridPromptSection(columnNames) {
   const commandDescriptions = Object.entries(gridCommands)
-    .map(([name, cmd]) => `- "${name}": ${cmd.description}`)
+    .map(([name, cmd]) => `- '${name}': ${cmd.description}`)
     .join("\n");
 
   return [
     'GRID: translate any part of the request that affects the task grid into one or more grid commands (the "actions" array).',
-    `Available columns (dataField): ${columnNames.join(", ")}.`,
+    `Available columns (dataField): ${columnNames.join(', ')}.`,
     "CRITICAL RULE: a column mentioned in the request must clearly correspond to one of the available " +
       'columns above (matching by meaning is fine, e.g. "due date" -> "DueDate"). If it does not - even ' +
       "if it superficially looks like it could be a column name - you must NOT invent or substitute the " +
@@ -257,10 +257,10 @@ function buildGridPromptSection(columnNames) {
       "with a different, existing column just to make the action valid.",
     'Example: request "filter the ZXQ column by foo" - ZXQ matches no available column, so emit ' +
       '{"column": "ZXQ", ...} as-is (it will correctly fail as "column not found") - do NOT emit an ' +
-      'action for "Subject" or any other real column instead.',
+      "action for 'Subject' or any other real column instead.",
     'The "Completion" column is a boolean: true means the task is completed, false means it is not. ' +
-      'To filter for "completed" tasks, use {"column": "Completion", "operator": "=", "value": true}. ' +
-      'To filter for "not completed" tasks, use {"column": "Completion", "operator": "=", "value": false}.',
+      "To filter for 'completed' tasks, use {'column': 'Completion', 'operator': '=', 'value': true}. " +
+      "To filter for 'not completed' tasks, use {'column': 'Completion', 'operator': '=', 'value': false}.",
     "Available grid commands:",
     commandDescriptions,
   ].join("\n");
@@ -276,8 +276,8 @@ function applyGridActions(grid, actions, rawText) {
 
     if (!command) {
       return {
-        status: "failure",
-        message: `I don't know how to do "${action.name}".`,
+        status: 'failure',
+        message: `I don't know how to do '${action.name}'.`,
       };
     }
 
diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.html b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.html
index 11eef21e09c0..af15e1c5f4c6 100644
--- a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.html
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.html
@@ -11,7 +11,7 @@
     <script src="../../../../node_modules/devextreme-dist/js/dx.ai-integration.js"></script>
 
     <script type="module">
-      import { AzureOpenAI } from "https://esm.sh/openai@4.73.1";
+      import { AzureOpenAI } from 'https://esm.sh/openai@4.73.1';
 
       window.AzureOpenAI = AzureOpenAI;
     </script>
diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.js b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.js
index 7dbefc978170..c223bc12c155 100644
--- a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.js
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.js
@@ -1,22 +1,22 @@
 $(function () {
   DevExpress.config({
-    editorStylingMode: "filled",
+    editorStylingMode: 'filled',
   });
 
   DevExpress.config({
     floatingActionButtonConfig: {
       position: {
-        my: "right bottom",
-        at: "right bottom",
-        of: "#grid-container",
-        offset: "-16 -16",
+        my: 'right bottom',
+        at: 'right bottom',
+        of: '#grid-container',
+        offset: '-16 -16',
       },
     },
   });
 
   DevExpress.localization.loadMessages({
     en: {
-      "dxChat-textareaPlaceholder": "Enter a prompt...",
+      'dxChat-textareaPlaceholder': 'Enter a prompt...',
     },
   });
 
@@ -27,20 +27,20 @@ $(function () {
   let gridInstance;
   let toastInstance;
 
-  toastInstance = $("#toast")
+  toastInstance = $('#toast')
     .dxToast({
       displayTime: 600,
       closeOnClick: true,
-      message: "Form data is saved.",
-      type: "success",
+      message: 'Form data is saved.',
+      type: 'success',
       position: {
-        of: "#form-container",
-        at: "bottom center",
-        my: "bottom center",
-        offset: "0 -20",
+        of: '#form-container',
+        at: 'bottom center',
+        my: 'bottom center',
+        offset: '0 -20',
       },
     })
-    .dxToast("instance");
+    .dxToast('instance');
 
   function pushMessage(message) {
     chatInstance
@@ -48,7 +48,7 @@ $(function () {
       .store()
       .push([
         {
-          type: "insert",
+          type: 'insert',
           data: {
             id: Date.now() + Math.random(),
             timestamp: new Date(),
@@ -59,12 +59,12 @@ $(function () {
   }
 
   function setDisabled(disabled) {
-    chatInstance.option("disabled", disabled);
+    chatInstance.option('disabled', disabled);
   }
 
   function updateClearButtonState() {
     const items = chatInstance.getDataSource().items();
-    clearButtonInstance?.option("disabled", items.length === 0);
+    clearButtonInstance?.option('disabled', items.length === 0);
   }
 
   function clearChat() {
@@ -93,38 +93,38 @@ $(function () {
     routed.finally(finish);
   }
 
-  popupInstance = $("#aiAssistantContainer")
+  popupInstance = $('#aiAssistantContainer')
     .dxPopup({
-      title: "AI Assistant",
+      title: 'AI Assistant',
       width: 400,
-      height: "90%",
+      height: '90%',
       dragEnabled: true,
       resizeEnabled: true,
       showCloseButton: true,
       shading: false,
       visible: false,
       onHiding() {
-        fabBtn.option("visible", true);
+        fabBtn.option('visible', true);
       },
       onShowing() {
-        fabBtn.option("visible", false);
+        fabBtn.option('visible', false);
       },
       position: {
-        my: "right top",
-        at: "right top",
-        of: ".demo-container",
-        offset: "-20 20",
+        my: 'right top',
+        at: 'right top',
+        of: '.demo-container',
+        offset: '-20 20',
       },
       toolbarItems: [
         {
-          widget: "dxButton",
-          toolbar: "top",
-          location: "after",
+          widget: 'dxButton',
+          toolbar: 'top',
+          location: 'after',
           cssClass: CLASSES.clearChatButton,
           options: {
-            icon: "clearhistory",
+            icon: 'clearhistory',
             disabled: true,
-            hint: "Clear chat",
+            hint: 'Clear chat',
             onClick: () => clearChat(),
             onInitialized: (e) => {
               clearButtonInstance = e.component;
@@ -133,27 +133,27 @@ $(function () {
         },
       ],
       contentTemplate($container) {
-        const $chatContainer = $("<div>")
-          .addClass("ai-chat-content")
+        const $chatContainer = $('<div>')
+          .addClass('ai-chat-content')
           .appendTo($container);
 
         $chatContainer.dxChat({
-          height: "100%",
+          height: '100%',
           showAvatar: false,
-          width: "auto",
+          width: 'auto',
           dataSource: {
-            store: new DevExpress.data.ArrayStore({ key: "id" }),
+            store: new DevExpress.data.ArrayStore({ key: 'id' }),
           },
           reloadOnChange: true,
-          user: { id: "user" },
+          user: { id: 'user' },
           showUserName: false,
           speechToTextEnabled: true,
           suggestions: {
             items: [
-              { text: "Show Completed Tasks", prompt: "Show Completed Tasks" },
+              { text: 'Show Completed Tasks', prompt: 'Show Completed Tasks' },
               {
-                text: "Change State to Texas",
-                prompt: "Change State to Texas",
+                text: 'Change State to Texas',
+                prompt: 'Change State to Texas',
               },
             ],
             onItemClick(e) {
@@ -161,7 +161,7 @@ $(function () {
               const message = {
                 id: Date.now() + Math.random(),
                 timestamp: new Date(),
-                author: { id: "user" },
+                author: { id: 'user' },
                 text: prompt,
               };
 
@@ -170,14 +170,14 @@ $(function () {
             },
           },
           emptyViewTemplate(_data, container) {
-            const $icon = $("<div>").addClass(
-              "dx-chat-messagelist-empty-image dx-ai-chat__empty-image",
+            const $icon = $('<div>').addClass(
+              'dx-chat-messagelist-empty-image dx-ai-chat__empty-image',
             );
-            const $message = $("<div>")
-              .addClass("ai-chat-empty-message")
+            const $message = $('<div>')
+              .addClass('ai-chat-empty-message')
               .text(emptyViewMessage);
-            const $prompt = $("<div>")
-              .addClass("ai-chat-empty-prompt")
+            const $prompt = $('<div>')
+              .addClass('ai-chat-empty-prompt')
               .html(emptyViewPrompt);
 
             $(container).append($icon).append($message).append($prompt);
@@ -191,32 +191,32 @@ $(function () {
         });
       },
     })
-    .dxPopup("instance");
+    .dxPopup('instance');
 
   const aiIntegration = createAiIntegration();
 
-  formInstance = $("#form-container")
+  formInstance = $('#form-container')
     .dxForm({
       formData: employee,
       colCount: 3,
-      labelLocation: "top",
+      labelLocation: 'top',
       onOptionChanged: (e) => {
-        if (e.name === "isDirty") {
-          const saveButton = formInstance.getButton("Save");
-          saveButton.option("disabled", !e.value);
+        if (e.name === 'isDirty') {
+          const saveButton = formInstance.getButton('Save');
+          saveButton.option('disabled', !e.value);
         }
       },
       aiIntegration,
       items: [
         {
-          dataField: "Prefix",
-          label: { text: "Title" },
-          editorType: "dxSelectBox",
+          dataField: 'Prefix',
+          label: { text: 'Title' },
+          editorType: 'dxSelectBox',
           editorOptions: { items: titles, searchEnabled: true },
           aiOptions: {
             instruction:
-              "Only fill this field with one of the allowed values (Mr., Mrs., Ms.) if a " +
-              "title is explicitly mentioned in the text. Never use this field for any part " +
+              'Only fill this field with one of the allowed values (Mr., Mrs., Ms.) if a ' +
+              'title is explicitly mentioned in the text. Never use this field for any part ' +
               "of a person's name.",
           },
         },
@@ -288,62 +288,67 @@ $(function () {
         },
       ],
     })
-    .dxForm("instance");
+    .dxForm('instance');
 
-  gridInstance = $("#grid-container")
+  gridInstance = $('#grid-container')
     .dxDataGrid({
       dataSource: tasks,
-      keyExpr: "ID",
+      keyExpr: 'ID',
       showBorders: true,
       filterRow: { visible: true },
       headerFilter: { visible: true },
       filterSyncEnabled: true,
       columns: [
-        { dataField: "Subject", width: 250 },
-        { dataField: "StartDate", dataType: "date" },
-        { dataField: "DueDate", dataType: "date" },
+        { dataField: 'Subject', width: 250 },
+        { dataField: 'StartDate', dataType: 'date' },
+        { dataField: 'DueDate', dataType: 'date' },
         {
-          dataField: "Priority",
-          caption: "Priority",
+          dataField: 'Priority',
+          caption: 'Priority',
           cellTemplate: (container, options) => {
-            $("<div>")
+            $('<div>')
               .css({
                 background: colors[options.value],
-                borderRadius: "24px",
-                padding: "2px 8px",
-                display: "inline-block",
-                textAlign: "center",
+                borderRadius: '24px',
+                padding: '2px 8px',
+                display: 'inline-block',
+                textAlign: 'center',
               })
               .text(options.value)
               .appendTo(container);
           },
         },
         {
-          dataField: "Completion",
-          caption: "Completed",
-          alignment: "center",
-          dataType: "boolean",
+          dataField: 'Completion',
+          caption: 'Completed',
+          alignment: 'center',
+          dataType: 'boolean',
+          editorOptions: {
+            elementAttr: {
+              'aria-label': 'Completed',
+            },
+          },
           calculateCellValue: (rowData) => rowData.Completion === 100,
           calculateFilterExpression(filterValue, selectedFilterOperation) {
             const wantsCompleted =
-              selectedFilterOperation === "<>" ? !filterValue : !!filterValue;
+              selectedFilterOperation === '<>' ? !filterValue : !!filterValue;
             const rawCompletion = (rowData) => rowData.Completion;
             return wantsCompleted
-              ? [rawCompletion, "=", 100]
-              : [rawCompletion, "<", 100];
+              ? [rawCompletion, '=', 100]
+              : [rawCompletion, '<', 100];
           },
         },
       ],
     })
-    .dxDataGrid("instance");
+    .dxDataGrid('instance');
 
-  let fabBtn = $("#ai-fab")
+  let fabBtn = $('#ai-fab')
     .dxSpeedDialAction({
-      icon: "sparkle",
-      label: "AI Assistant",
+      icon: 'sparkle',
+      label: 'AI Assistant',
       onClick: function (e) {
         popupInstance.toggle();
       },
     })
-    .dxSpeedDialAction("instance");
+    .dxSpeedDialAction('instance');
 });
diff --git a/apps/demos/eslint.config.mjs b/apps/demos/eslint.config.mjs
index 393ce938ab60..142fb68f8dc6 100644
--- a/apps/demos/eslint.config.mjs
+++ b/apps/demos/eslint.config.mjs
@@ -316,6 +316,18 @@ export default [
       'no-unused-vars': 0,
     },
   },
+  {
+    files: [
+      'Demos/Chat/CustomAIAssistant/jQuery/ai-service.js',
+      'Demos/Chat/CustomAIAssistant/jQuery/chat-router.js',
+      'Demos/Chat/CustomAIAssistant/jQuery/form-commands.js',
+      'Demos/Chat/CustomAIAssistant/jQuery/grid-commands.js',
+    ],
+    rules: {
+      'no-undef': 0,
+      'no-unused-vars': 0,
+    },
+  },
 
   // React demos
   {
diff --git a/apps/demos/testing/etalons/Chat-CustomAIAssistant (fluent.blue.light).png b/apps/demos/testing/etalons/Chat-CustomAIAssistant (fluent.blue.light).png
new file mode 100644
index 0000000000000000000000000000000000000000..9bcb47a4fe71b02a67bf7e043f1f9c284dcc6e53
GIT binary patch
literal 70581
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

literal 0
HcmV?d00001

diff --git a/apps/demos/testing/etalons/Chat-CustomAIAssistant (material.blue.light).png b/apps/demos/testing/etalons/Chat-CustomAIAssistant (material.blue.light).png
new file mode 100644
index 0000000000000000000000000000000000000000..2413725f1106d4b2cb2862b4f0021a45c8d6063e
GIT binary patch
literal 68270
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

literal 0
HcmV?d00001


From 55b5ceeae1fb812a85961ec5bdb4d6cc004a807d Mon Sep 17 00:00:00 2001
From: Diana Gromova <16adianay@gmail.com>
Date: Thu, 3 Sep 2026 17:15:15 +0400
Subject: [PATCH 3/7] Update CSP config

---
 apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.html | 2 +-
 apps/demos/utils/server/csp-server.js                     | 6 ++++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.html b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.html
index af15e1c5f4c6..11eef21e09c0 100644
--- a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.html
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.html
@@ -11,7 +11,7 @@
     <script src="../../../../node_modules/devextreme-dist/js/dx.ai-integration.js"></script>
 
     <script type="module">
-      import { AzureOpenAI } from 'https://esm.sh/openai@4.73.1';
+      import { AzureOpenAI } from "https://esm.sh/openai@4.73.1";
 
       window.AzureOpenAI = AzureOpenAI;
     </script>
diff --git a/apps/demos/utils/server/csp-server.js b/apps/demos/utils/server/csp-server.js
index 5b2243644fd6..1994de2cafe6 100644
--- a/apps/demos/utils/server/csp-server.js
+++ b/apps/demos/utils/server/csp-server.js
@@ -140,6 +140,9 @@ const CSP_DEMO_ALLOWLIST = {
   'Chat/AIAndChatbotIntegration': {
     'connect-src': DEMO_OPENAI_CONNECT_SRC,
   },
+  'Chat/CustomAIAssistant': {
+    'connect-src': DEMO_OPENAI_CONNECT_SRC,
+  },
   'Chat/MessageStreaming': {
     'connect-src': DEMO_OPENAI_CONNECT_SRC,
   },
@@ -210,6 +213,9 @@ const CSP_FRAMEWORK_ALLOWLIST = {
     'Chat/AIAndChatbotIntegration': {
       'script-src': ["'unsafe-inline'"],
     },
+    'Chat/CustomAIAssistant': {
+      'script-src': ["'unsafe-inline'"],
+    },
     'Chat/MessageStreaming': {
       'script-src': ["'unsafe-inline'"],
     },

From c028a8ab85b8914bb91538fcef2783ebb00b9a1a Mon Sep 17 00:00:00 2001
From: Diana Gromova <16adianay@gmail.com>
Date: Thu, 3 Sep 2026 17:43:26 +0400
Subject: [PATCH 4/7] Fix lint errors

---
 .../CustomAIAssistant/jQuery/ai-service.js    |   4 +-
 .../CustomAIAssistant/jQuery/chat-router.js   |   3 +-
 .../CustomAIAssistant/jQuery/form-commands.js |   8 +-
 .../CustomAIAssistant/jQuery/grid-commands.js | 108 +++++++++---------
 .../Chat/CustomAIAssistant/jQuery/index.js    |  58 +++++-----
 5 files changed, 89 insertions(+), 92 deletions(-)

diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/ai-service.js b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/ai-service.js
index 5571107b6ff5..be820653865d 100644
--- a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/ai-service.js
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/ai-service.js
@@ -64,8 +64,8 @@ function createAiIntegration() {
         : (prompt.system ?? '');
 
       const aiPrompt = [
-        { role: "system", content: system },
-        { role: "user", content: prompt.user },
+        { role: 'system', content: system },
+        { role: 'user', content: prompt.user },
       ];
       const promise = getAIResponseRecursive(aiPrompt, signal);
 
diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/chat-router.js b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/chat-router.js
index 958e0ff849a7..5999d359c59a 100644
--- a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/chat-router.js
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/chat-router.js
@@ -120,7 +120,6 @@ function buildGridResultsPromise(gridInstance, aiIntegration, text) {
 
   return executeAiCommand(prompt, aiIntegration)
     .then((parsed) => {
-
       const actions = Array.isArray(parsed.actions) ? parsed.actions : [];
 
       if (actions.length === 0) {
@@ -255,7 +254,7 @@ function reportAiResult(promise, pushMessage) {
           : '❌ I couldn\'t reach the AI service. Please check your connection and try again.';
 
       pushMessage({
-        author: { id: "ai", name: "AI Assistant" },
+        author: { id: 'ai', name: 'AI Assistant' },
         text,
       });
     });
diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/form-commands.js b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/form-commands.js
index 4d7e58ce75f9..10ae5ff75828 100644
--- a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/form-commands.js
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/form-commands.js
@@ -60,11 +60,11 @@ function applyFormSmartPaste(form, text) {
       const fieldCount = Object.keys(e.aiResult ?? {}).length;
       finish(
         fieldCount > 0
-            ? { status: 'success', message: 'Updated the form.' }
+          ? { status: 'success', message: 'Updated the form.' }
           : {
-              status: 'failure',
-              message: "I couldn't find any Form fields matching the request.",
-            },
+            status: 'failure',
+            message: "I couldn't find any Form fields matching the request.",
+          },
       );
     };
 
diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/grid-commands.js b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/grid-commands.js
index 08b74e4e24e7..59d65e82d152 100644
--- a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/grid-commands.js
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/grid-commands.js
@@ -14,33 +14,33 @@ const gridCommands = {
       'cannot be inferred from elsewhere in the request (e.g. plain "in May" with no year anywhere), do ' +
       'not guess it - omit this action entirely instead of adding it with a made-up year.',
     schema: {
-      type: "object",
+      type: 'object',
       properties: {
-        column: { type: "string" },
+        column: { type: 'string' },
         operator: {
-          type: "string",
+          type: 'string',
           enum: [
-            "=",
-            "<>",
-            "<",
-            "<=",
-            ">",
-            ">=",
-            "contains",
-            "notcontains",
-            "startswith",
-            "endswith",
-            "anyof",
+            '=',
+            '<>',
+            '<',
+            '<=',
+            '>',
+            '>=',
+            'contains',
+            'notcontains',
+            'startswith',
+            'endswith',
+            'anyof',
           ],
         },
         value: {
           anyOf: [
-            { type: ["string", "number", "boolean"] },
-            { type: "array", items: { type: "string" } },
+            { type: ['string', 'number', 'boolean'] },
+            { type: 'array', items: { type: 'string' } },
           ],
         },
       },
-      required: ["column", "operator", "value"],
+      required: ['column', 'operator', 'value'],
     },
     execute(grid, args, rawText) {
       const { column, failure } = getColumnOrFail(grid, args.column);
@@ -68,13 +68,13 @@ const gridCommands = {
 
       if (args.operator === 'anyof' && Array.isArray(value)) {
         const mentionedYears = new Set(
-          String(rawText ?? "").match(/\b\d{4}\b/g),
+          String(rawText ?? '').match(/\b\d{4}\b/g),
         );
-        const hasUngroundedYear = value.some(
-          (entry) => !mentionedYears.has(String(entry).split("/")[0]),
+        const hasUnrecognizedYear = value.some(
+          (entry) => !mentionedYears.has(String(entry).split('/')[0]),
         );
 
-        if (hasUngroundedYear) {
+        if (hasUnrecognizedYear) {
           return {
             status: 'failure',
             message: 'No field or column exists with such a name, or the entered value is invalid.',
@@ -98,8 +98,8 @@ const gridCommands = {
   },
 
   clearFilter: {
-    description: "Clear all filters on the grid.",
-    schema: { type: "object", properties: {} },
+    description: 'Clear all filters on the grid.',
+    schema: { type: 'object', properties: {} },
     execute(grid) {
       try {
         grid.clearFilter();
@@ -117,12 +117,12 @@ const gridCommands = {
     description:
       'Sort a column ascending or descending. Pass sortOrder "none" to remove sorting from this column only.',
     schema: {
-      type: "object",
+      type: 'object',
       properties: {
-        column: { type: "string" },
-        sortOrder: { type: "string", enum: ["asc", "desc", "none"] },
+        column: { type: 'string' },
+        sortOrder: { type: 'string', enum: ['asc', 'desc', 'none'] },
       },
-      required: ["column", "sortOrder"],
+      required: ['column', 'sortOrder'],
     },
     execute(grid, args) {
       const { column, failure } = getColumnOrFail(grid, args.column);
@@ -142,10 +142,10 @@ const gridCommands = {
             ? `Cleared sorting on '${caption}'.`
             : `Sorted by '${caption}' (${args.sortOrder === 'asc' ? 'ascending' : 'descending'}).`;
 
-        return { status: "success", message };
+        return { status: 'success', message };
       } catch {
         return {
-          status: "failure",
+          status: 'failure',
           message: `I couldn't sort by '${caption}'.`,
         };
       }
@@ -153,8 +153,8 @@ const gridCommands = {
   },
 
   clearSorting: {
-    description: "Remove sorting from all columns.",
-    schema: { type: "object", properties: {} },
+    description: 'Remove sorting from all columns.',
+    schema: { type: 'object', properties: {} },
     execute(grid) {
       try {
         grid.clearSorting();
@@ -169,14 +169,14 @@ const gridCommands = {
   },
 
   columnsVisibility: {
-    description: "Show or hide a column.",
+    description: 'Show or hide a column.',
     schema: {
-      type: "object",
+      type: 'object',
       properties: {
-        column: { type: "string" },
-        visible: { type: "boolean" },
+        column: { type: 'string' },
+        visible: { type: 'boolean' },
       },
-      required: ["column", "visible"],
+      required: ['column', 'visible'],
     },
     execute(grid, args) {
       const { column, failure } = getColumnOrFail(grid, args.column);
@@ -185,7 +185,7 @@ const gridCommands = {
       const caption = column.caption ?? args.column;
 
       try {
-        grid.columnOption(args.column, "visible", args.visible);
+        grid.columnOption(args.column, 'visible', args.visible);
         return {
           status: 'success',
           message: args.visible
@@ -219,51 +219,51 @@ function getColumnOrFail(grid, columnName) {
 }
 
 function buildGridResponseSchema() {
-  const branches = Object.entries(gridCommands).map(([name, cmd]) => ({
-    type: "object",
+  const branches = Object.entries(gridCommands).map(([name, command]) => ({
+    type: 'object',
     properties: {
-      name: { type: "string", enum: [name] },
-      args: cmd.schema,
+      name: { type: 'string', enum: [name] },
+      args: command.schema,
     },
-    required: ["name", "args"],
+    required: ['name', 'args'],
   }));
 
   return {
-    type: "object",
+    type: 'object',
     properties: {
       actions: {
-        type: "array",
-        description: "List of grid commands to execute, in order.",
+        type: 'array',
+        description: 'List of grid commands to execute, in order.',
         items: { anyOf: branches },
       },
     },
-    required: ["actions"],
+    required: ['actions'],
   };
 }
 
 function buildGridPromptSection(columnNames) {
   const commandDescriptions = Object.entries(gridCommands)
-    .map(([name, cmd]) => `- '${name}': ${cmd.description}`)
-    .join("\n");
+    .map(([name, command]) => `- '${name}': ${command.description}`)
+    .join('\n');
 
   return [
     'GRID: translate any part of the request that affects the task grid into one or more grid commands (the "actions" array).',
     `Available columns (dataField): ${columnNames.join(', ')}.`,
-    "CRITICAL RULE: a column mentioned in the request must clearly correspond to one of the available " +
+    'CRITICAL RULE: a column mentioned in the request must clearly correspond to one of the available ' +
       'columns above (matching by meaning is fine, e.g. "due date" -> "DueDate"). If it does not - even ' +
-      "if it superficially looks like it could be a column name - you must NOT invent or substitute the " +
-      "closest-sounding available column. Instead, still emit the action using the column name exactly " +
+      'if it superficially looks like it could be a column name - you must NOT invent or substitute the ' +
+      'closest-sounding available column. Instead, still emit the action using the column name exactly ' +
       "as written in the request, so the app can report that the column wasn't found - never replace it " +
-      "with a different, existing column just to make the action valid.",
+      'with a different, existing column just to make the action valid.',
     'Example: request "filter the ZXQ column by foo" - ZXQ matches no available column, so emit ' +
       '{"column": "ZXQ", ...} as-is (it will correctly fail as "column not found") - do NOT emit an ' +
       "action for 'Subject' or any other real column instead.",
     'The "Completion" column is a boolean: true means the task is completed, false means it is not. ' +
       "To filter for 'completed' tasks, use {'column': 'Completion', 'operator': '=', 'value': true}. " +
       "To filter for 'not completed' tasks, use {'column': 'Completion', 'operator': '=', 'value': false}.",
-    "Available grid commands:",
+    'Available grid commands:',
     commandDescriptions,
-  ].join("\n");
+  ].join('\n');
 }
 
 function getGridColumnNames(gridInstance) {
diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.js b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.js
index c223bc12c155..91b472d76d85 100644
--- a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.js
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.js
@@ -1,4 +1,4 @@
-$(function () {
+$(() => {
   DevExpress.config({
     editorStylingMode: 'filled',
   });
@@ -21,13 +21,11 @@ $(function () {
   });
 
   let chatInstance;
-  let popupInstance;
   let clearButtonInstance;
   let formInstance;
   let gridInstance;
-  let toastInstance;
 
-  toastInstance = $('#toast')
+  const toastInstance = $('#toast')
     .dxToast({
       displayTime: 600,
       closeOnClick: true,
@@ -93,7 +91,7 @@ $(function () {
     routed.finally(finish);
   }
 
-  popupInstance = $('#aiAssistantContainer')
+  const popupInstance = $('#aiAssistantContainer')
     .dxPopup({
       title: 'AI Assistant',
       width: 400,
@@ -221,66 +219,66 @@ $(function () {
           },
         },
         {
-          dataField: "FirstName",
-          label: { text: "First Name" },
+          dataField: 'FirstName',
+          label: { text: 'First Name' },
           aiOptions: {
             instruction:
               "Only fill this field if the text clearly refers to a person's given name. " +
-              "Never use grid/task-related words like Subject, Priority, Status, Due Date, " +
-              "Completion, or generic verbs like sort/filter/show as a name.",
+              'Never use grid/task-related words like Subject, Priority, Status, Due Date, ' +
+              'Completion, or generic verbs like sort/filter/show as a name.',
           },
         },
         {
-          dataField: "LastName",
-          label: { text: "Last Name" },
+          dataField: 'LastName',
+          label: { text: 'Last Name' },
           aiOptions: {
             instruction:
               "If the text gives a full person name (e.g. 'customer name', 'employee name') " +
-              "without separately labeled first/last names, use only the first word as First " +
-              "Name and the rest of the name as Last Name.",
+              'without separately labeled first/last names, use only the first word as First ' +
+              'Name and the rest of the name as Last Name.',
           },
         },
         {
-          dataField: "Position",
-          editorType: "dxSelectBox",
+          dataField: 'Position',
+          editorType: 'dxSelectBox',
           editorOptions: { items: positions, searchEnabled: true },
           aiOptions: {
             instruction:
-              "Only fill this field with one of the allowed job position values if the text " +
+              'Only fill this field with one of the allowed job position values if the text ' +
               "explicitly refers to the employee's own job title/role.",
           },
         },
         {
-          dataField: "State",
-          editorType: "dxSelectBox",
+          dataField: 'State',
+          editorType: 'dxSelectBox',
           editorOptions: { items: states, searchEnabled: true },
           aiOptions: {
             instruction:
-              "Only fill this field with one of the allowed US state values if the text " +
+              'Only fill this field with one of the allowed US state values if the text ' +
               "explicitly refers to the employee's home/office state",
           },
         },
         {
-          dataField: "BirthDate",
-          editorType: "dxDateBox",
-          editorOptions: { displayFormat: "M/d/yyyy" },
+          dataField: 'BirthDate',
+          editorType: 'dxDateBox',
+          editorOptions: { displayFormat: 'M/d/yyyy' },
           aiOptions: {
             instruction:
               "Only fill this field if the text explicitly refers to the employee's own birth " +
-              "date or date of birth.",
+              'date or date of birth.',
           },
         },
         {
-          itemType: "button",
-          name: "Save",
+          itemType: 'button',
+          name: 'Save',
           colSpan: 3,
-          cssClass: "save-button",
+          cssClass: 'save-button',
           buttonOptions: {
-            text: "Save",
-            type: "default",
+            text: 'Save',
+            type: 'default',
             disabled: true,
             useSubmitBehavior: true,
-            width: "120px",
+            width: '120px',
             onClick: () => {
               toastInstance.show();
             },
@@ -346,7 +344,7 @@ $(function () {
     .dxSpeedDialAction({
       icon: 'sparkle',
       label: 'AI Assistant',
-      onClick: function (e) {
+      onClick() {
         popupInstance.toggle();
       },
     })

From 8c00e93482149fc096f36790f5c5f81d28c9df29 Mon Sep 17 00:00:00 2001
From: Diana Gromova <16adianay@gmail.com>
Date: Thu, 3 Sep 2026 18:47:11 +0400
Subject: [PATCH 5/7] Fix Copilot suggestions

---
 .../Demos/Chat/CustomAIAssistant/jQuery/chat-router.js      | 6 ++++++
 .../Demos/Chat/CustomAIAssistant/jQuery/form-commands.js    | 6 ++++++
 .../Demos/Chat/CustomAIAssistant/jQuery/grid-commands.js    | 2 +-
 apps/demos/Demos/Chat/CustomAIAssistant/jQuery/styles.css   | 4 ++--
 4 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/chat-router.js b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/chat-router.js
index 5999d359c59a..58dcfd252a1e 100644
--- a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/chat-router.js
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/chat-router.js
@@ -195,6 +195,12 @@ async function runCommand(text, { form, gridInstance, aiIntegration }) {
     form,
   );
 
+  if (target === "none") {
+    throw new ChatCommandError(
+      "❌ This request doesn't appear to be related to Form or DataGrid. Please try rephrasing it.",
+    );
+  }
+
   if (target === 'form') {
     const { results: formResults, error: formError } =
       await buildFormResultsPromise(form, formAction, text);
diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/form-commands.js b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/form-commands.js
index 10ae5ff75828..91fe4319b0d9 100644
--- a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/form-commands.js
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/form-commands.js
@@ -47,6 +47,7 @@ function applyFormClearAction(form, formAction) {
 function applyFormSmartPaste(form, text) {
   return new Promise((resolve) => {
     let settled = false;
+    let timedOut = false;
 
     const finish = (result) => {
       if (settled) return;
@@ -57,6 +58,10 @@ function applyFormSmartPaste(form, text) {
     };
 
     const handleSmartPasted = (e) => {
+      if (timedOut) {
+        return;
+      }
+
       const fieldCount = Object.keys(e.aiResult ?? {}).length;
       finish(
         fieldCount > 0
@@ -69,6 +74,7 @@ function applyFormSmartPaste(form, text) {
     };
 
     const timeoutId = setTimeout(() => {
+      timedOut = true;
       finish({
         status: 'failure',
         message: "I couldn't process your request. Please try rephrasing it.",
diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/grid-commands.js b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/grid-commands.js
index 59d65e82d152..410449e9820e 100644
--- a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/grid-commands.js
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/grid-commands.js
@@ -267,7 +267,7 @@ function buildGridPromptSection(columnNames) {
 }
 
 function getGridColumnNames(gridInstance) {
-  return gridInstance.getVisibleColumns().map((col) => col.dataField);
+  return gridInstance.option('columns').map((col) => col.dataField);
 }
 
 function applyGridActions(grid, actions, rawText) {
diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/styles.css b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/styles.css
index 2031731a987e..67dc0dc46149 100644
--- a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/styles.css
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/styles.css
@@ -34,7 +34,7 @@
   font-size: 18px;
   font-weight: 400;
   text-align: center;
-  color: #242424;
+  color: var(--dx-color-text);
   margin-bottom: 8px;
 }
 
@@ -50,7 +50,7 @@
   margin-right: 8px;
 }
 
-.dx-popup-content {
+#aiAssistantContainer .dx-popup-content {
   padding: 0;
 }
 

From 9b7361869e77cc15ff890f816ea61d44b76d6792 Mon Sep 17 00:00:00 2001
From: Diana Gromova <16adianay@gmail.com>
Date: Thu, 3 Sep 2026 18:55:10 +0400
Subject: [PATCH 6/7] Add a custom class to a popup wrapper

---
 apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.js   | 3 +++
 apps/demos/Demos/Chat/CustomAIAssistant/jQuery/styles.css | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.js b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.js
index 91b472d76d85..9f505d5c4a8f 100644
--- a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.js
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/index.js
@@ -94,6 +94,9 @@ $(() => {
   const popupInstance = $('#aiAssistantContainer')
     .dxPopup({
       title: 'AI Assistant',
+      wrapperAttr: {
+        class: 'chat-popup',
+      },
       width: 400,
       height: '90%',
       dragEnabled: true,
diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/styles.css b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/styles.css
index 67dc0dc46149..9f2f499ed6f9 100644
--- a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/styles.css
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/styles.css
@@ -50,7 +50,7 @@
   margin-right: 8px;
 }
 
-#aiAssistantContainer .dx-popup-content {
+.chat-popup .dx-popup-content {
   padding: 0;
 }
 

From 8ce4563921fd44f6a445d87256ec5dc662db488a Mon Sep 17 00:00:00 2001
From: Diana Gromova <16adianay@gmail.com>
Date: Thu, 3 Sep 2026 19:15:28 +0400
Subject: [PATCH 7/7] Update chat-router.js

---
 apps/demos/Demos/Chat/CustomAIAssistant/jQuery/chat-router.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/chat-router.js b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/chat-router.js
index 58dcfd252a1e..b47be23dd6d1 100644
--- a/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/chat-router.js
+++ b/apps/demos/Demos/Chat/CustomAIAssistant/jQuery/chat-router.js
@@ -195,7 +195,7 @@ async function runCommand(text, { form, gridInstance, aiIntegration }) {
     form,
   );
 
-  if (target === "none") {
+  if (target === 'none') {
     throw new ChatCommandError(
       "❌ This request doesn't appear to be related to Form or DataGrid. Please try rephrasing it.",
     );