[Streams] Use TS instead of FROM for TSDB mode in Discover links

x-pack/platform/packages/shared/kbn-streams-schema/index.ts

@@ -6,7 +6,7 @@
  */
 
 export { Streams } from './src/models/streams';
-export { IngestBase } from './src/models/ingest/base';
+export { IngestBase, type IngestStreamIndexMode } from './src/models/ingest/base';
 export { Ingest } from './src/models/ingest';
 export { WiredIngest } from './src/models/ingest/wired';
 export { ClassicIngest } from './src/models/ingest/classic';

x-pack/platform/packages/shared/kbn-streams-schema/src/models/ingest/base.ts

@@ -114,6 +114,8 @@ type IngestBaseStreamDefaults = {
 } & ModelOfSchema<IIngestBaseStreamSchema>;
 
 /* eslint-disable @typescript-eslint/no-namespace */
+export type IngestStreamIndexMode = 'standard' | 'time_series' | 'logsdb' | 'lookup';
+
 export namespace IngestBaseStream {
   export interface Definition extends BaseStream.Definition {
     ingest: IngestBase;
@@ -127,6 +129,7 @@ export namespace IngestBaseStream {
     TDefinition extends IngestBaseStream.Definition = IngestBaseStream.Definition
   > extends BaseStream.GetResponse<TDefinition> {
     privileges: IngestStreamPrivileges;
+    index_mode?: IngestStreamIndexMode;
   }
 
   export type UpsertRequest<
@@ -141,13 +144,21 @@ export namespace IngestBaseStream {
   }
 }
 
+const ingestStreamIndexModeSchema: z.Schema<IngestStreamIndexMode> = z.enum([
+  'standard',
+  'time_series',
+  'logsdb',
+  'lookup',
+]);
+
 const IngestBaseStreamSchema = {
   Source: z.object({}),
   Definition: z.object({
     ingest: IngestBase.right,
   }),
   GetResponse: z.object({
     privileges: ingestStreamPrivilegesSchema,
+    index_mode: z.optional(ingestStreamIndexModeSchema),
   }),
   UpsertRequest: z.object({}),
 };

x-pack/platform/plugins/shared/streams/server/routes/streams/crud/read_stream.ts

@@ -11,6 +11,7 @@ import {
   getInheritedFieldsFromAncestors,
   getInheritedSettings,
   findInheritedFailureStore,
+  type IngestStreamIndexMode,
 } from '@kbn/streams-schema';
 import type { IScopedClusterClient } from '@kbn/core/server';
 import { isNotFoundError } from '@kbn/es-errors';
@@ -91,6 +92,7 @@ export async function readStream({
     return {
       stream: streamDefinition,
       privileges,
+      index_mode: dataStream?.index_mode as IngestStreamIndexMode | undefined,
       elasticsearch_assets:
         dataStream && privileges.manage
           ? await getUnmanagedElasticsearchAssets({
@@ -130,6 +132,7 @@ export async function readStream({
     rules,
     privileges,
     queries,
+    index_mode: dataStream?.index_mode as IngestStreamIndexMode | undefined,
     effective_lifecycle: findInheritedLifecycle(streamDefinition, ancestors),
     effective_settings: getInheritedSettings([...ancestors, streamDefinition]),
     inherited_fields: inheritedFields,

x-pack/platform/plugins/shared/streams_app/public/components/stream_badges/index.tsx

@@ -167,20 +167,26 @@ export function LifecycleBadge({
 export function DiscoverBadgeButton({
   definition,
   isWiredStream,
+  isTSDBMode: isTSDBModeProp,
 }: {
   definition: Streams.ingest.all.GetResponse;
   isWiredStream: boolean;
+  /** When provided from listing data, uses this instead of definition.index_mode */
+  isTSDBMode?: boolean;
 }) {
   const {
     dependencies: {
       start: { share },
     },
   } = useKibana();
+  // Use prop if provided (from listing data), otherwise use index_mode from definition (API response)
+  const isTSDBMode = isTSDBModeProp ?? definition.index_mode === 'time_series';
   const dataStreamExists =
     Streams.WiredStream.GetResponse.is(definition) || definition.data_stream_exists;
   const indexPatterns = getIndexPatternsForStream(definition.stream);
+  const sourceCommand = isTSDBMode ? 'TS' : 'FROM';
   const esqlQuery = indexPatterns
-    ? `FROM ${indexPatterns.join(', ')}${isWiredStream ? ' METADATA _source' : ''}`
+    ? `${sourceCommand} ${indexPatterns.join(', ')}${isWiredStream ? ' METADATA _source' : ''}`
     : undefined;
   const useUrl = share.url.locators.useUrl;
 

x-pack/platform/plugins/shared/streams_app/public/components/stream_detail_overview/child_stream_list.tsx

@@ -12,20 +12,40 @@ import { type Streams, isDescendantOf } from '@kbn/streams-schema';
 
 import { useStreamsAppRouter } from '../../hooks/use_streams_app_router';
 import { AssetImage } from '../asset_image';
-import { StreamsList } from '../streams_list';
-import { useWiredStreams } from '../../hooks/use_wired_streams';
+import { StreamsList, type StreamListItem } from '../streams_list';
+import { useKibana } from '../../hooks/use_kibana';
+import { useStreamsAppFetch } from '../../hooks/use_streams_app_fetch';
 
 export function ChildStreamList({ definition }: { definition?: Streams.ingest.all.GetResponse }) {
   const router = useStreamsAppRouter();
+  const {
+    dependencies: {
+      start: {
+        streams: { streamsRepositoryClient },
+      },
+    },
+  } = useKibana();
 
-  const { wiredStreams } = useWiredStreams();
+  // Fetch from internal API to get data_stream info for TSDB mode detection
+  const { value: streamsResponse } = useStreamsAppFetch(
+    async ({ signal }) =>
+      streamsRepositoryClient.fetch('GET /internal/streams', {
+        signal,
+      }),
+    [streamsRepositoryClient]
+  );
 
-  const childrenStreams = useMemo(() => {
-    if (!definition) {
-      return [];
+  const childrenStreams = useMemo((): StreamListItem[] | undefined => {
+    if (!definition || !streamsResponse?.streams) {
+      return undefined;
     }
-    return wiredStreams?.filter((d) => isDescendantOf(definition.stream.name, d.name));
-  }, [definition, wiredStreams]);
+    return streamsResponse.streams
+      .filter((item) => isDescendantOf(definition.stream.name, item.stream.name))
+      .map((item) => ({
+        stream: item.stream,
+        data_stream: item.data_stream,
+      }));
+  }, [definition, streamsResponse?.streams]);
 
   if (definition && childrenStreams?.length === 0) {
     return (

x-pack/platform/plugins/shared/streams_app/public/components/stream_detail_overview/components/stream_chart_panel.tsx

@@ -54,20 +54,24 @@ export function StreamChartPanel({ definition }: StreamChartPanelProps) {
     [data, timeState.asAbsoluteTimeRange]
   );
 
+  // Use index_mode from API response instead of expensive DataView check
+  const isTSDBMode = definition.index_mode === 'time_series';
+
   const queries = useMemo(() => {
     if (!indexPatterns) {
       return undefined;
     }
 
-    const baseQuery = `FROM ${indexPatterns.join(', ')}`;
+    const sourceCommand = isTSDBMode ? 'TS' : 'FROM';
+    const baseQuery = `${sourceCommand} ${indexPatterns.join(', ')}`;
 
     const histogramQuery = `${baseQuery} | STATS metric = COUNT(*) BY @timestamp = BUCKET(@timestamp, ${bucketSize})`;
 
     return {
       baseQuery,
       histogramQuery,
     };
-  }, [bucketSize, indexPatterns]);
+  }, [bucketSize, indexPatterns, isTSDBMode]);
 
   const discoverLink = useMemo(() => {
     if (!discoverLocator || !queries?.baseQuery) {

x-pack/platform/plugins/shared/streams_app/public/components/stream_detail_systems/stream_systems/system_events_data.tsx

@@ -14,6 +14,7 @@ import { conditionToESQL } from '@kbn/streamlang';
 import type { DiscoverAppLocatorParams } from '@kbn/discover-plugin/common';
 import { DISCOVER_APP_LOCATOR } from '@kbn/discover-plugin/common';
 import { useKibana } from '../../../hooks/use_kibana';
+import { useStreamDetail } from '../../../hooks/use_stream_detail';
 import { SystemEventsSparklineLast24hrs } from './system_events_sparkline';
 
 export const SystemEventsData = ({
@@ -28,9 +29,15 @@ export const SystemEventsData = ({
       start: { share },
     },
   } = useKibana();
+  // Get index_mode from the stream detail context (API response)
+  const { definition: fullDefinition } = useStreamDetail();
+  const isTSDBMode =
+    Streams.ingest.all.GetResponse.is(fullDefinition) &&
+    fullDefinition.index_mode === 'time_series';
   const useUrl = share.url.locators.useUrl;
 
-  const esqlQuery = `FROM ${getIndexPatternsForStream(definition).join(',')}
+  const sourceCommand = isTSDBMode ? 'TS' : 'FROM';
+  const esqlQuery = `${sourceCommand} ${getIndexPatternsForStream(definition).join(',')}
       | WHERE ${conditionToESQL(system.filter)}`;
 
   const discoverLink = useUrl<DiscoverAppLocatorParams>(

x-pack/platform/plugins/shared/streams_app/public/components/stream_list_view/tree_table.tsx

@@ -501,6 +501,7 @@ export function StreamsTreeTable({
                 } as Streams.ingest.all.GetResponse
               }
               isWiredStream={item.type === 'wired'}
+              isTSDBMode={item.data_stream?.index_mode === 'time_series'}
             />
           ),
         },

x-pack/platform/plugins/shared/streams_app/public/components/streams_list/index.tsx

@@ -27,40 +27,50 @@ import {
   isDescendantOf,
   isRootStreamDefinition,
 } from '@kbn/streams-schema';
+import type { estypes } from '@elastic/elasticsearch';
 import { useStreamsAppRouter } from '../../hooks/use_streams_app_router';
 import { NestedView } from '../nested_view';
 import { useKibana } from '../../hooks/use_kibana';
 
+export interface StreamListItem {
+  stream: Streams.all.Definition;
+  data_stream?: estypes.IndicesDataStream;
+}
+
 export interface StreamTree {
   name: string;
   type: 'wired' | 'root' | 'classic';
   stream: Streams.all.Definition;
+  data_stream?: estypes.IndicesDataStream;
   children: StreamTree[];
 }
 
-export function asTrees(streams: Streams.all.Definition[]) {
+export function asTrees(items: StreamListItem[]) {
   const trees: StreamTree[] = [];
-  const sortedStreams = streams
+  const sortedItems = items
     .slice()
-    .sort((a, b) => getSegments(a.name).length - getSegments(b.name).length);
+    .sort((a, b) => getSegments(a.stream.name).length - getSegments(b.stream.name).length);
 
-  sortedStreams.forEach((stream) => {
+  sortedItems.forEach((item) => {
     let currentTree = trees;
     let existingNode: StreamTree | undefined;
     // traverse the tree following the prefix of the current name.
     // once we reach the leaf, the current name is added as child - this works because the ids are sorted by depth
-    while ((existingNode = currentTree.find((node) => isDescendantOf(node.name, stream.name)))) {
+    while (
+      (existingNode = currentTree.find((node) => isDescendantOf(node.name, item.stream.name)))
+    ) {
       currentTree = existingNode.children;
     }
 
     if (!existingNode) {
       const newNode: StreamTree = {
-        name: stream.name,
+        name: item.stream.name,
         children: [],
-        stream,
-        type: Streams.ClassicStream.Definition.is(stream)
+        stream: item.stream,
+        data_stream: item.data_stream,
+        type: Streams.ClassicStream.Definition.is(item.stream)
           ? 'classic'
-          : isRootStreamDefinition(stream)
+          : isRootStreamDefinition(item.stream)
           ? 'root'
           : 'wired',
       };
@@ -76,7 +86,7 @@ export function StreamsList({
   query,
   showControls,
 }: {
-  streams: Streams.all.Definition[] | undefined;
+  streams: StreamListItem[] | undefined;
   query?: string;
   showControls: boolean;
 }) {
@@ -88,8 +98,8 @@ export function StreamsList({
 
   const filteredItems = useMemo(() => {
     return items
-      .filter((item) => showClassic || Streams.WiredStream.Definition.is(item))
-      .filter((item) => !query || item.name.toLowerCase().includes(query.toLowerCase()));
+      .filter((item) => showClassic || Streams.WiredStream.Definition.is(item.stream))
+      .filter((item) => !query || item.stream.name.toLowerCase().includes(query.toLowerCase()));
   }, [query, items, showClassic]);
 
   const treeView = useMemo(() => asTrees(filteredItems), [filteredItems]);
@@ -113,7 +123,7 @@ export function StreamsList({
                   iconType="fold"
                   size="s"
                   onClick={() =>
-                    setCollapsed(Object.fromEntries(items.map((item) => [item.name, true])))
+                    setCollapsed(Object.fromEntries(items.map((item) => [item.stream.name, true])))
                   }
                 >
                   {i18n.translate('xpack.streams.streamsTable.collapseAll', {
@@ -178,19 +188,23 @@ function StreamNode({
     [share.url.locators]
   );
 
+  // Use TSDB mode from data_stream.index_mode directly from listing data
+  const isTSDBMode = node.data_stream?.index_mode === 'time_series';
+
   const discoverUrl = useMemo(() => {
     const indexPatterns = getIndexPatternsForStream(node.stream);
 
     if (!discoverLocator || !indexPatterns) {
       return undefined;
     }
 
+    const sourceCommand = isTSDBMode ? 'TS' : 'FROM';
     return discoverLocator.getRedirectUrl({
       query: {
-        esql: `FROM ${indexPatterns.join(', ')}`,
+        esql: `${sourceCommand} ${indexPatterns.join(', ')}`,
       },
     });
-  }, [discoverLocator, node]);
+  }, [discoverLocator, node, isTSDBMode]);
 
   return (
     <EuiFlexGroup

x-pack/platform/plugins/shared/streams_app/test/scout/ui/fixtures/page_objects/streams_app.ts

@@ -158,7 +158,7 @@ export class StreamsApp {
     ).toContainText(expectedIlmPolicy);
   }
 
-  async verifyDiscoverButtonLink(streamName: string) {
+  async verifyDiscoverButtonLink(streamName: string, sourceCommand: 'FROM' | 'TS' = 'FROM') {
     const locator = this.page.locator(
       `[data-test-subj="streamsDiscoverActionButton-${streamName}"]`
     );
@@ -170,15 +170,38 @@ export class StreamsApp {
     }
 
     // Expect encoded ESQL snippet to appear (basic validation)
-    // 'FROM <streamName>' should appear URL-encoded
-    const expectedFragment = encodeURIComponent(`FROM ${streamName}`);
+    // '<sourceCommand> <streamName>' should appear URL-encoded
+    const expectedFragment = encodeURIComponent(`${sourceCommand} ${streamName}`);
     if (!href.includes(expectedFragment)) {
       throw new Error(
         `Href for ${streamName} did not contain expected ESQL fragment. href=${href} expectedFragment=${expectedFragment}`
       );
     }
   }
 
+  async getDiscoverButtonLinkSourceCommand(streamName: string): Promise<'FROM' | 'TS' | null> {
+    const locator = this.page.locator(
+      `[data-test-subj="streamsDiscoverActionButton-${streamName}"]`
+    );
+    await locator.waitFor();
+
+    const href = await locator.getAttribute('href');
+    if (!href) {
+      return null;
+    }
+
+    // Check which source command is used in the URL
+    const fromFragment = encodeURIComponent(`FROM ${streamName}`);
+    const tsFragment = encodeURIComponent(`TS ${streamName}`);
+
+    if (href.includes(tsFragment)) {
+      return 'TS';
+    } else if (href.includes(fromFragment)) {
+      return 'FROM';
+    }
+    return null;
+  }
+
   async verifyStreamsAreInTable(streamNames: string[]) {
     for (const name of streamNames) {
       await expect(