@inkeep/agents-manage-ui 0.31.3 → 0.31.5

package/src/lib/api/signoz-stats.ts

@@ -6,6 +6,7 @@ import {
   AI_OPERATIONS,
   AI_TOOL_TYPES,
   DATA_SOURCES,
+  DATA_TYPES,
   OPERATORS,
   ORDER_DIRECTIONS,
   PANEL_TYPES,
@@ -87,6 +88,8 @@ const FilterValueSchema = z.union([z.string(), z.number(), z.boolean()]);
 
 type FilterValue = z.infer<typeof FilterValueSchema>;
 
+type DataType = (typeof DATA_TYPES)[keyof typeof DATA_TYPES];
+
 const asTypedFilterValue = (v: string): FilterValue => {
   try {
     // Handle boolean values
@@ -163,146 +166,266 @@ class SigNozStatsAPI {
   async getConversationStats(
     startTime: number,
     endTime: number,
-    filters?: SpanFilterOptions,
-    projectId?: string,
-    pagination?: { page: number; limit: number },
-    searchQuery?: string,
-    agentId?: string
-  ): Promise<ConversationStats[] | PaginatedConversationStats> {
+    filters: SpanFilterOptions | undefined,
+    projectId: string | undefined,
+    pagination: { page: number; limit: number },
+    searchQuery: string | undefined,
+    agentId: string | undefined
+  ): Promise<PaginatedConversationStats> {
     try {
-      const payload = this.buildCombinedPayload(startTime, endTime, filters, projectId, agentId);
-      const resp = await this.makeRequest(payload);
+      return await this.getConversationStatsPaginated(
+        startTime,
+        endTime,
+        filters,
+        projectId,
+        pagination,
+        searchQuery,
+        agentId
+      );
+    } catch (e) {
+      console.error('getConversationStats error:', e);
+      return {
+        data: [],
+        pagination: {
+          page: pagination.page,
+          limit: pagination.limit,
+          total: 0,
+          totalPages: 0,
+          hasNextPage: false,
+          hasPreviousPage: false,
+        },
+      };
+    }
+  }
 
-      const toolsSeries = this.extractSeries(resp, QUERY_EXPRESSIONS.TOOLS);
-      const transfersSeries = this.extractSeries(resp, QUERY_EXPRESSIONS.TRANSFERS);
-      const delegationsSeries = this.extractSeries(resp, QUERY_EXPRESSIONS.DELEGATIONS);
-      const aiCallsSeries = this.extractSeries(resp, QUERY_EXPRESSIONS.AI_CALLS);
-      const lastActivitySeries = this.extractSeries(resp, QUERY_EXPRESSIONS.LAST_ACTIVITY);
-      const metadataSeries = this.extractSeries(resp, QUERY_EXPRESSIONS.CONVERSATION_METADATA);
-      const spansWithErrorsSeries = this.extractSeries(resp, QUERY_EXPRESSIONS.SPANS_WITH_ERRORS);
-      const userMessagesSeries = this.extractSeries(resp, QUERY_EXPRESSIONS.USER_MESSAGES);
-
-      // metadata map
-      const metaByConv = new Map<
-        string,
-        { tenantId: string; agentId: string; agentName: string }
-      >();
-      for (const s of metadataSeries) {
-        const id = s.labels?.[SPAN_KEYS.CONVERSATION_ID];
-        if (!id) continue;
-        metaByConv.set(id, {
-          tenantId: s.labels?.[SPAN_KEYS.TENANT_ID] ?? UNKNOWN_VALUE,
-          agentId: s.labels?.[SPAN_KEYS.AGENT_ID] ?? UNKNOWN_VALUE,
-          agentName: s.labels?.[SPAN_KEYS.AGENT_NAME] ?? UNKNOWN_VALUE,
-        });
+  private async getConversationStatsPaginated(
+    startTime: number,
+    endTime: number,
+    filters: SpanFilterOptions | undefined,
+    projectId: string | undefined,
+    pagination: { page: number; limit: number },
+    searchQuery: string | undefined,
+    agentId: string | undefined
+  ): Promise<PaginatedConversationStats> {
+    // Step 1: Get total count and paginated conversation IDs sorted by last activity
+    const { conversationIds, total } = await this.getPaginatedConversationIds(
+      startTime,
+      endTime,
+      filters,
+      projectId,
+      pagination,
+      searchQuery,
+      agentId
+    );
+
+    if (conversationIds.length === 0) {
+      return {
+        data: [],
+        pagination: {
+          page: pagination.page,
+          limit: pagination.limit,
+          total,
+          totalPages: Math.ceil(total / pagination.limit),
+          hasNextPage: pagination.page < Math.ceil(total / pagination.limit),
+          hasPreviousPage: pagination.page > 1,
+        },
+      };
+    }
+
+    // Step 2: Fetch detailed stats only for the paginated conversation IDs
+    const payload = this.buildCombinedPayload(
+      startTime,
+      endTime,
+      filters,
+      projectId,
+      agentId,
+      conversationIds
+    );
+    const resp = await this.makeRequest(payload);
+
+    const toolsSeries = this.extractSeries(resp, QUERY_EXPRESSIONS.TOOLS);
+    const transfersSeries = this.extractSeries(resp, QUERY_EXPRESSIONS.TRANSFERS);
+    const delegationsSeries = this.extractSeries(resp, QUERY_EXPRESSIONS.DELEGATIONS);
+    const aiCallsSeries = this.extractSeries(resp, QUERY_EXPRESSIONS.AI_CALLS);
+    const lastActivitySeries = this.extractSeries(resp, QUERY_EXPRESSIONS.LAST_ACTIVITY);
+    const metadataSeries = this.extractSeries(resp, QUERY_EXPRESSIONS.CONVERSATION_METADATA);
+    const spansWithErrorsSeries = this.extractSeries(resp, QUERY_EXPRESSIONS.SPANS_WITH_ERRORS);
+    const userMessagesSeries = this.extractSeries(resp, QUERY_EXPRESSIONS.USER_MESSAGES);
+
+    // metadata map
+    const metaByConv = new Map<string, { tenantId: string; agentId: string; agentName: string }>();
+    for (const s of metadataSeries) {
+      const id = s.labels?.[SPAN_KEYS.CONVERSATION_ID];
+      if (!id) continue;
+      metaByConv.set(id, {
+        tenantId: s.labels?.[SPAN_KEYS.TENANT_ID] ?? UNKNOWN_VALUE,
+        agentId: s.labels?.[SPAN_KEYS.AGENT_ID] ?? UNKNOWN_VALUE,
+        agentName: s.labels?.[SPAN_KEYS.AGENT_NAME] ?? UNKNOWN_VALUE,
+      });
+    }
+
+    // first seen map
+    const firstSeen = new Map<string, number>();
+    for (const s of lastActivitySeries) {
+      const id = s.labels?.[SPAN_KEYS.CONVERSATION_ID];
+      if (!id) continue;
+      firstSeen.set(id, numberFromSeries(s));
+    }
+
+    // first user message per conversation
+    const firstMsgByConv = new Map<string, { content: string; timestamp: number }>();
+    const msgsByConv = new Map<string, Array<{ t: number; c: string }>>();
+    for (const s of userMessagesSeries) {
+      const id = s.labels?.[SPAN_KEYS.CONVERSATION_ID];
+      const content = s.labels?.[SPAN_KEYS.MESSAGE_CONTENT];
+      const t = numberFromSeries(s);
+      if (!id || !content) continue;
+      (msgsByConv.get(id) ?? msgsByConv.set(id, []).get(id))?.push({
+        t,
+        c: content,
+      });
+    }
+    for (const [id, arr] of msgsByConv) {
+      arr.sort((a, b) => a.t - b.t);
+      const first = arr[0];
+      if (first) {
+        const content = first.c.length > 100 ? `${first.c.slice(0, 100)}...` : first.c;
+        firstMsgByConv.set(id, { content, timestamp: nsToMs(first.t) });
       }
+    }
+
+    // build stats
+    const stats = this.toConversationStats(
+      toolsSeries,
+      transfersSeries,
+      delegationsSeries,
+      aiCallsSeries,
+      metaByConv,
+      spansWithErrorsSeries,
+      firstMsgByConv
+    );
+
+    // Filter to only include the paginated conversation IDs (in the correct order)
+    const statsMap = new Map(stats.map((s) => [s.conversationId, s]));
+    const orderedStats = conversationIds
+      .map((id) => statsMap.get(id))
+      .filter((s): s is ConversationStats => s !== undefined);
+
+    // Sort by first activity to maintain order
+    orderedStats.sort((a, b) =>
+      byFirstActivity(firstSeen.get(a.conversationId), firstSeen.get(b.conversationId))
+    );
+
+    return {
+      data: orderedStats,
+      pagination: {
+        page: pagination.page,
+        limit: pagination.limit,
+        total,
+        totalPages: Math.ceil(total / pagination.limit),
+        hasNextPage: pagination.page < Math.ceil(total / pagination.limit),
+        hasPreviousPage: pagination.page > 1,
+      },
+    };
+  }
+
+  private async getPaginatedConversationIds(
+    startTime: number,
+    endTime: number,
+    filters: SpanFilterOptions | undefined,
+    projectId: string | undefined,
+    pagination: { page: number; limit: number },
+    searchQuery: string | undefined,
+    agentId: string | undefined
+  ): Promise<{ conversationIds: string[]; total: number }> {
+    // Consolidated query: fetch all required data in a single request
+    const consolidatedPayload = this.buildFilteredConversationIdsPayload(
+      startTime,
+      endTime,
+      filters,
+      projectId,
+      agentId,
+      !!searchQuery?.trim()
+    );
+
+    const consolidatedResp = await this.makeRequest(consolidatedPayload);
 
-      // first seen map
-      const firstSeen = new Map<string, number>();
-      for (const s of lastActivitySeries) {
+    // Extract activity data (always needed for sorting)
+    const activitySeries = this.extractSeries(consolidatedResp, QUERY_EXPRESSIONS.LAST_ACTIVITY);
+    const activityMap = new Map<string, number>();
+    for (const s of activitySeries) {
+      const id = s.labels?.[SPAN_KEYS.CONVERSATION_ID];
+      if (!id) continue;
+      activityMap.set(id, numberFromSeries(s));
+    }
+
+    // Start with all conversation IDs from activity data
+    let conversationIds = Array.from(activityMap.keys());
+
+    // Apply span filters if needed
+    if (filters?.spanName || filters?.attributes?.length) {
+      const filteredSeries = this.extractSeries(
+        consolidatedResp,
+        QUERY_EXPRESSIONS.FILTERED_CONVERSATIONS
+      );
+      const filteredIds = new Set(
+        filteredSeries.map((s) => s.labels?.[SPAN_KEYS.CONVERSATION_ID]).filter(Boolean) as string[]
+      );
+      conversationIds = conversationIds.filter((id) => filteredIds.has(id));
+    }
+
+    // Apply search filtering if needed
+    if (searchQuery?.trim()) {
+      const metadataSeries = this.extractSeries(
+        consolidatedResp,
+        QUERY_EXPRESSIONS.CONVERSATION_METADATA
+      );
+      const metadataMap = new Map<string, { agentId: string; conversationId: string }>();
+      for (const s of metadataSeries) {
         const id = s.labels?.[SPAN_KEYS.CONVERSATION_ID];
+        const agentIdValue = s.labels?.[SPAN_KEYS.AGENT_ID];
         if (!id) continue;
-        firstSeen.set(id, numberFromSeries(s));
+        metadataMap.set(id, { agentId: agentIdValue ?? '', conversationId: id });
       }
 
-      // first user message per conversation (min timestamp already grouped)
-      const firstMsgByConv = new Map<string, { content: string; timestamp: number }>();
-      const msgsByConv = new Map<string, Array<{ t: number; c: string }>>();
+      const userMessagesSeries = this.extractSeries(
+        consolidatedResp,
+        QUERY_EXPRESSIONS.USER_MESSAGES
+      );
+      const firstMessagesMap = new Map<string, string>();
       for (const s of userMessagesSeries) {
         const id = s.labels?.[SPAN_KEYS.CONVERSATION_ID];
         const content = s.labels?.[SPAN_KEYS.MESSAGE_CONTENT];
-        const t = numberFromSeries(s);
         if (!id || !content) continue;
-        (msgsByConv.get(id) ?? msgsByConv.set(id, []).get(id))?.push({
-          t,
-          c: content,
-        });
-      }
-      for (const [id, arr] of msgsByConv) {
-        arr.sort((a, b) => a.t - b.t);
-        const first = arr[0];
-        if (first) {
-          const content = first.c.length > 100 ? `${first.c.slice(0, 100)}...` : first.c;
-          firstMsgByConv.set(id, { content, timestamp: nsToMs(first.t) });
+        if (!firstMessagesMap.has(id)) {
+          firstMessagesMap.set(id, content);
         }
       }
 
-      // build stats
-      let stats = this.toConversationStats(
-        toolsSeries,
-        transfersSeries,
-        delegationsSeries,
-        aiCallsSeries,
-        metaByConv,
-        spansWithErrorsSeries,
-        firstMsgByConv
-      );
-
-      // optional secondary filter pass via span filters
-      if (filters?.spanName || filters?.attributes?.length) {
-        stats = await this.applySpanFilters(stats, startTime, endTime, filters, projectId);
-      }
-
-      // search filter
-      if (searchQuery?.trim()) {
-        const q = searchQuery.toLowerCase().trim();
-        stats = stats.filter(
-          (s) =>
-            s.firstUserMessage?.toLowerCase().includes(q) ||
-            s.conversationId.toLowerCase().includes(q) ||
-            s.agentId.toLowerCase().includes(q)
+      const q = searchQuery.toLowerCase().trim();
+      conversationIds = conversationIds.filter((id) => {
+        const meta = metadataMap.get(id);
+        const firstMsg = firstMessagesMap.get(id);
+        return (
+          firstMsg?.toLowerCase().includes(q) ||
+          id.toLowerCase().includes(q) ||
+          meta?.agentId.toLowerCase().includes(q)
         );
-      }
-
-      // sort by first activity
-      stats.sort((a, b) =>
-        byFirstActivity(firstSeen.get(a.conversationId), firstSeen.get(b.conversationId))
-      );
-
-      if (!pagination) return stats;
+      });
+    }
 
-      const { page, limit } = pagination;
-      const total = stats.length;
-      const totalPages = Math.ceil(total / limit);
-      const start = (page - 1) * limit;
-      const data = stats.slice(start, start + limit);
+    // Sort by last activity (descending - most recent first)
+    conversationIds.sort((a, b) => {
+      const aTime = activityMap.get(a) ?? 0;
+      const bTime = activityMap.get(b) ?? 0;
+      return bTime - aTime; // Descending order
+    });
 
-      return {
-        data,
-        pagination: {
-          page,
-          limit,
-          total,
-          totalPages,
-          hasNextPage: page < totalPages,
-          hasPreviousPage: page > 1,
-        },
-      };
-    } catch (e) {
-      console.error('getConversationStats error:', e);
-      return [];
-    }
-  }
+    const total = conversationIds.length;
+    const start = (pagination.page - 1) * pagination.limit;
+    const paginatedIds = conversationIds.slice(start, start + pagination.limit);
 
-  async getAICallsByAgent(startTime: number, endTime: number, projectId?: string) {
-    try {
-      const resp = await this.makeRequest(
-        this.buildCombinedPayload(startTime, endTime, undefined, projectId)
-      );
-      const series = this.extractSeries(resp, QUERY_EXPRESSIONS.AI_CALLS);
-      const totals = new Map<string, number>();
-      for (const s of series) {
-        const agentId = s.labels?.[SPAN_KEYS.AGENT_ID] || UNKNOWN_VALUE;
-        const count = countFromSeries(s);
-        if (count) totals.set(agentId, (totals.get(agentId) || 0) + count);
-      }
-      return [...totals]
-        .map(([agentId, totalCalls]) => ({ agentId, totalCalls }))
-        .sort((a, b) => b.totalCalls - a.totalCalls);
-    } catch (e) {
-      console.error('getAICallsByAgent error:', e);
-      return [];
-    }
+    return { conversationIds: paginatedIds, total };
   }
 
   async getAICallsBySubAgent(
@@ -469,51 +592,57 @@ class SigNozStatsAPI {
     agentId?: string
   ) {
     try {
-      const resp = await this.makeRequest(
-        this.buildCombinedPayload(startTime, endTime, filters, projectId, agentId)
-      );
-
-      const toolsSeries = this.extractSeries(resp, 'tools');
-      const transfersSeries = this.extractSeries(resp, 'transfers');
-      const delegationsSeries = this.extractSeries(resp, 'delegations');
-      const aiCallsSeries = this.extractSeries(resp, 'aiCalls');
-      const metadataSeries = this.extractSeries(resp, 'conversationMetadata');
-      const spansWithErrorsSeries = this.extractSeries(resp, QUERY_EXPRESSIONS.SPANS_WITH_ERRORS);
-
-      const metaByConv = new Map<
-        string,
-        { tenantId: string; agentId: string; agentName: string }
-      >();
-      for (const s of metadataSeries) {
-        const id = s.labels?.[SPAN_KEYS.CONVERSATION_ID];
-        if (!id) continue;
-        metaByConv.set(id, {
-          tenantId: s.labels?.[SPAN_KEYS.TENANT_ID] ?? UNKNOWN_VALUE,
-          agentId: s.labels?.[SPAN_KEYS.AGENT_ID] ?? UNKNOWN_VALUE,
-          agentName: s.labels?.[SPAN_KEYS.AGENT_NAME] ?? UNKNOWN_VALUE,
-        });
+      // If span filters are applied, first get the conversation IDs that match those filters
+      let filteredConversationIds: string[] | undefined;
+      if (filters?.spanName || filters?.attributes?.length) {
+        const filteredPayload = this.buildFilteredConversationsPayload(
+          startTime,
+          endTime,
+          filters,
+          projectId
+        );
+        const filteredResp = await this.makeRequest(filteredPayload);
+        const filteredSeries = this.extractSeries(filteredResp, 'filteredConversations');
+        filteredConversationIds = filteredSeries
+          .map((s) => s.labels?.[SPAN_KEYS.CONVERSATION_ID])
+          .filter(Boolean) as string[];
+
+        if (filteredConversationIds.length === 0) {
+          // No conversations match the filters, return zeros
+          return {
+            totalToolCalls: 0,
+            totalTransfers: 0,
+            totalDelegations: 0,
+            totalConversations: 0,
+            totalAICalls: 0,
+          };
+        }
       }
 
-      let stats = this.toConversationStats(
-        toolsSeries,
-        transfersSeries,
-        delegationsSeries,
-        aiCallsSeries,
-        metaByConv,
-        spansWithErrorsSeries,
-        new Map<string, { content: string; timestamp: number }>()
+      const payload = this.buildAggregateBadgesPayload(
+        startTime,
+        endTime,
+        projectId,
+        agentId,
+        filteredConversationIds
       );
 
-      if (filters?.spanName || filters?.attributes?.length) {
-        stats = await this.applySpanFilters(stats, startTime, endTime, filters, projectId);
-      }
+      const resp = await this.makeRequest(payload);
+
+      const toolCallsSeries = this.extractSeries(resp, 'totalToolCalls');
+      const transfersSeries = this.extractSeries(resp, 'totalTransfers');
+      const delegationsSeries = this.extractSeries(resp, 'totalDelegations');
+      const aiCallsSeries = this.extractSeries(resp, 'totalAICalls');
+      const conversationsSeries = this.extractSeries(resp, 'totalConversations');
 
       return {
-        totalToolCalls: stats.reduce((s, r) => s + r.totalToolCalls, 0),
-        totalTransfers: stats.reduce((s, r) => s + r.totalTransfers, 0),
-        totalDelegations: stats.reduce((s, r) => s + r.totalDelegations, 0),
-        totalConversations: stats.length,
-        totalAICalls: stats.reduce((s, r) => s + r.totalAICalls, 0),
+        totalToolCalls: countFromSeries(toolCallsSeries[0] || { values: [{ value: '0' }] }),
+        totalTransfers: countFromSeries(transfersSeries[0] || { values: [{ value: '0' }] }),
+        totalDelegations: countFromSeries(delegationsSeries[0] || { values: [{ value: '0' }] }),
+        totalConversations: filteredConversationIds
+          ? filteredConversationIds.length
+          : countFromSeries(conversationsSeries[0] || { values: [{ value: '0' }] }),
+        totalAICalls: countFromSeries(aiCallsSeries[0] || { values: [{ value: '0' }] }),
       };
     } catch (e) {
       console.error('getAggregateStats error:', e);
@@ -775,28 +904,6 @@ class SigNozStatsAPI {
     return out;
   }
 
-  private async applySpanFilters(
-    stats: ConversationStats[],
-    startTime: number,
-    endTime: number,
-    filters: SpanFilterOptions,
-    projectId?: string
-  ) {
-    try {
-      const resp = await this.makeRequest(
-        this.buildFilteredConversationsPayload(startTime, endTime, filters, projectId)
-      );
-      const series = this.extractSeries(resp, 'filteredConversations');
-      const allowed = new Set<string>(
-        series.map((s) => s.labels?.[SPAN_KEYS.CONVERSATION_ID]).filter(Boolean) as string[]
-      );
-      return stats.filter((s) => allowed.has(s.conversationId));
-    } catch (e) {
-      console.error('applySpanFilters error:', e);
-      return stats;
-    }
-  }
-
   // ---------- Payload builders (unchanged behavior, less repetition)
 
   private buildAgentModelBreakdownPayload(start: number, end: number, projectId?: string) {
@@ -1138,94 +1245,382 @@ class SigNozStatsAPI {
     };
   }
 
-  private buildFilteredConversationsPayload(
+  private buildFilteredConversationIdsPayload(
     start: number,
     end: number,
-    filters: SpanFilterOptions,
-    projectId?: string
+    filters: SpanFilterOptions | undefined,
+    projectId: string | undefined,
+    agentId: string | undefined,
+    includeSearchData: boolean
   ) {
-    const items: any[] = [
-      {
-        key: {
-          key: SPAN_KEYS.CONVERSATION_ID,
-          ...QUERY_FIELD_CONFIGS.STRING_TAG,
+    const buildBaseFilters = (): any[] => {
+      const items: any[] = [
+        {
+          key: {
+            key: SPAN_KEYS.CONVERSATION_ID,
+            ...QUERY_FIELD_CONFIGS.STRING_TAG,
+          },
+          op: OPERATORS.EXISTS,
+          value: '',
         },
-        op: OPERATORS.EXISTS,
-        value: '',
-      },
-    ];
-
-    if (filters.spanName) {
-      items.push({
-        key: { key: SPAN_KEYS.NAME, ...QUERY_FIELD_CONFIGS.STRING_TAG_COLUMN },
-        op: OPERATORS.EQUALS,
-        value: filters.spanName,
-      });
-    }
-
-    // Attribute filters — pass typed booleans/numbers where possible
-    for (const attr of filters.attributes ?? []) {
-      const op = attr.operator ?? OPERATORS.EQUALS;
-      let value: any = asTypedFilterValue(attr.value);
-      let dataType: 'string' | 'int64' | 'float64' | 'bool' = 'string';
-      if (typeof value === 'boolean') dataType = 'bool';
-      else if (typeof value === 'number') dataType = Number.isInteger(value) ? 'int64' : 'float64';
+      ];
 
-      // exists/nexists ignore value
-      if (op === OPERATORS.EXISTS || op === OPERATORS.NOT_EXISTS) {
+      if (agentId && agentId !== 'all') {
         items.push({
-          key: { key: attr.key, ...QUERY_FIELD_CONFIGS.STRING_TAG },
-          op,
-          value: '',
+          key: {
+            key: SPAN_KEYS.AGENT_ID,
+            ...QUERY_FIELD_CONFIGS.STRING_TAG,
+          },
+          op: OPERATORS.EQUALS,
+          value: agentId,
         });
-        continue;
-      }
-
-      // LIKE operators add wildcards if absent
-      if (
-        (op === OPERATORS.LIKE || op === OPERATORS.NOT_LIKE) &&
-        typeof value === 'string' &&
-        !value.includes('%')
-      ) {
-        value = `%${value}%`;
       }
 
-      // For numeric equality, keep exact-match pair (>= & <=) for robustness
-      if ((dataType === 'int64' || dataType === 'float64') && op === OPERATORS.EQUALS) {
-        const config =
-          dataType === 'int64' ? QUERY_FIELD_CONFIGS.INT64_TAG : QUERY_FIELD_CONFIGS.FLOAT64_TAG;
+      if (projectId) {
         items.push({
-          key: { key: attr.key, ...config },
-          op: OPERATORS.GREATER_THAN_OR_EQUAL,
-          value,
+          key: {
+            key: SPAN_KEYS.PROJECT_ID,
+            ...QUERY_FIELD_CONFIGS.STRING_TAG,
+          },
+          op: OPERATORS.EQUALS,
+          value: projectId,
         });
-        items.push({
-          key: { key: attr.key, ...config },
-          op: OPERATORS.LESS_THAN_OR_EQUAL,
-          value,
+      }
+
+      return items;
+    };
+
+    const builderQueries: Record<string, any> = {
+      // Always include activity query for sorting
+      lastActivity: {
+        dataSource: DATA_SOURCES.TRACES,
+        queryName: QUERY_EXPRESSIONS.LAST_ACTIVITY,
+        aggregateOperator: AGGREGATE_OPERATORS.MIN,
+        aggregateAttribute: {
+          key: SPAN_KEYS.TIMESTAMP,
+          ...QUERY_FIELD_CONFIGS.INT64_TAG_COLUMN,
+        },
+        filters: { op: OPERATORS.AND, items: buildBaseFilters() },
+        groupBy: [
+          {
+            key: SPAN_KEYS.CONVERSATION_ID,
+            ...QUERY_FIELD_CONFIGS.STRING_TAG,
+          },
+        ],
+        expression: QUERY_EXPRESSIONS.LAST_ACTIVITY,
+        reduceTo: REDUCE_OPERATIONS.MIN,
+        stepInterval: QUERY_DEFAULTS.STEP_INTERVAL,
+        orderBy: [{ columnName: SPAN_KEYS.TIMESTAMP, order: ORDER_DIRECTIONS.DESC }],
+        offset: QUERY_DEFAULTS.OFFSET,
+        disabled: QUERY_DEFAULTS.DISABLED,
+        having: QUERY_DEFAULTS.HAVING,
+        legend: QUERY_DEFAULTS.LEGEND,
+        limit: QUERY_DEFAULTS.LIMIT_UNLIMITED,
+      },
+    };
+
+    // Add filtered conversations query if filters are provided
+    if (filters?.spanName || filters?.attributes?.length) {
+      const filterItems: any[] = [
+        {
+          key: {
+            key: SPAN_KEYS.CONVERSATION_ID,
+            ...QUERY_FIELD_CONFIGS.STRING_TAG,
+          },
+          op: OPERATORS.EXISTS,
+          value: '',
+        },
+      ];
+
+      if (filters.spanName) {
+        filterItems.push({
+          key: { key: SPAN_KEYS.NAME, ...QUERY_FIELD_CONFIGS.STRING_TAG_COLUMN },
+          op: OPERATORS.EQUALS,
+          value: filters.spanName,
         });
-      } else {
-        const config =
-          dataType === 'string'
-            ? QUERY_FIELD_CONFIGS.STRING_TAG
-            : dataType === 'int64'
-              ? QUERY_FIELD_CONFIGS.INT64_TAG
-              : dataType === 'float64'
-                ? QUERY_FIELD_CONFIGS.FLOAT64_TAG
-                : QUERY_FIELD_CONFIGS.BOOL_TAG;
-        items.push({ key: { key: attr.key, ...config }, op, value });
       }
-    }
 
-    if (projectId) {
-      items.push({
-        key: { key: SPAN_KEYS.PROJECT_ID, ...QUERY_FIELD_CONFIGS.STRING_TAG },
-        op: OPERATORS.EQUALS,
-        value: projectId,
-      });
-    }
+      // Attribute filters
+      for (const attr of filters.attributes ?? []) {
+        const op = attr.operator ?? OPERATORS.EQUALS;
+        let value: any = asTypedFilterValue(attr.value);
+        let dataType: DataType = DATA_TYPES.STRING;
+        if (typeof value === 'boolean') dataType = DATA_TYPES.BOOL;
+        else if (typeof value === 'number')
+          dataType = Number.isInteger(value) ? DATA_TYPES.INT64 : DATA_TYPES.FLOAT64;
+
+        if (op === OPERATORS.EXISTS || op === OPERATORS.NOT_EXISTS) {
+          filterItems.push({
+            key: { key: attr.key, ...QUERY_FIELD_CONFIGS.STRING_TAG },
+            op,
+            value: '',
+          });
+          continue;
+        }
 
-    return {
+        if (
+          (op === OPERATORS.LIKE || op === OPERATORS.NOT_LIKE) &&
+          typeof value === 'string' &&
+          !value.includes('%')
+        ) {
+          value = `%${value}%`;
+        }
+
+        if (
+          (dataType === DATA_TYPES.INT64 || dataType === DATA_TYPES.FLOAT64) &&
+          op === OPERATORS.EQUALS
+        ) {
+          const config =
+            dataType === DATA_TYPES.INT64
+              ? QUERY_FIELD_CONFIGS.INT64_TAG
+              : QUERY_FIELD_CONFIGS.FLOAT64_TAG;
+          filterItems.push({
+            key: { key: attr.key, ...config },
+            op: OPERATORS.GREATER_THAN_OR_EQUAL,
+            value,
+          });
+          filterItems.push({
+            key: { key: attr.key, ...config },
+            op: OPERATORS.LESS_THAN_OR_EQUAL,
+            value,
+          });
+        } else {
+          const config =
+            dataType === DATA_TYPES.STRING
+              ? QUERY_FIELD_CONFIGS.STRING_TAG
+              : dataType === DATA_TYPES.INT64
+                ? QUERY_FIELD_CONFIGS.INT64_TAG
+                : dataType === DATA_TYPES.FLOAT64
+                  ? QUERY_FIELD_CONFIGS.FLOAT64_TAG
+                  : QUERY_FIELD_CONFIGS.BOOL_TAG;
+          filterItems.push({ key: { key: attr.key, ...config }, op, value });
+        }
+      }
+
+      if (projectId) {
+        filterItems.push({
+          key: { key: SPAN_KEYS.PROJECT_ID, ...QUERY_FIELD_CONFIGS.STRING_TAG },
+          op: OPERATORS.EQUALS,
+          value: projectId,
+        });
+      }
+
+      builderQueries.filteredConversations = {
+        dataSource: DATA_SOURCES.TRACES,
+        queryName: QUERY_EXPRESSIONS.FILTERED_CONVERSATIONS,
+        aggregateOperator: AGGREGATE_OPERATORS.COUNT,
+        aggregateAttribute: {
+          key: SPAN_KEYS.SPAN_ID,
+          ...QUERY_FIELD_CONFIGS.STRING_TAG_COLUMN,
+        },
+        filters: { op: OPERATORS.AND, items: filterItems },
+        groupBy: [
+          {
+            key: SPAN_KEYS.CONVERSATION_ID,
+            ...QUERY_FIELD_CONFIGS.STRING_TAG,
+          },
+        ],
+        expression: QUERY_EXPRESSIONS.FILTERED_CONVERSATIONS,
+        reduceTo: REDUCE_OPERATIONS.SUM,
+        stepInterval: QUERY_DEFAULTS.STEP_INTERVAL,
+        orderBy: [{ columnName: SPAN_KEYS.TIMESTAMP, order: ORDER_DIRECTIONS.DESC }],
+        offset: QUERY_DEFAULTS.OFFSET,
+        disabled: QUERY_DEFAULTS.DISABLED,
+        having: QUERY_DEFAULTS.HAVING,
+        legend: QUERY_DEFAULTS.LEGEND,
+        limit: QUERY_DEFAULTS.LIMIT_UNLIMITED,
+      };
+    }
+
+    // Add metadata and user messages queries if search is needed
+    if (includeSearchData) {
+      const metadataFilters = buildBaseFilters();
+      metadataFilters.push(
+        {
+          key: { key: SPAN_KEYS.TENANT_ID, ...QUERY_FIELD_CONFIGS.STRING_TAG },
+          op: OPERATORS.EXISTS,
+          value: '',
+        },
+        {
+          key: { key: SPAN_KEYS.AGENT_ID, ...QUERY_FIELD_CONFIGS.STRING_TAG },
+          op: OPERATORS.EXISTS,
+          value: '',
+        }
+      );
+
+      builderQueries.conversationMetadata = {
+        dataSource: DATA_SOURCES.TRACES,
+        queryName: QUERY_EXPRESSIONS.CONVERSATION_METADATA,
+        aggregateOperator: AGGREGATE_OPERATORS.COUNT,
+        aggregateAttribute: {
+          key: SPAN_KEYS.SPAN_ID,
+          ...QUERY_FIELD_CONFIGS.STRING_TAG_COLUMN,
+        },
+        filters: { op: OPERATORS.AND, items: metadataFilters },
+        groupBy: [
+          {
+            key: SPAN_KEYS.CONVERSATION_ID,
+            ...QUERY_FIELD_CONFIGS.STRING_TAG,
+          },
+          { key: SPAN_KEYS.TENANT_ID, ...QUERY_FIELD_CONFIGS.STRING_TAG },
+          { key: SPAN_KEYS.AGENT_ID, ...QUERY_FIELD_CONFIGS.STRING_TAG },
+          { key: SPAN_KEYS.AGENT_NAME, ...QUERY_FIELD_CONFIGS.STRING_TAG },
+        ],
+        expression: QUERY_EXPRESSIONS.CONVERSATION_METADATA,
+        reduceTo: REDUCE_OPERATIONS.SUM,
+        stepInterval: QUERY_DEFAULTS.STEP_INTERVAL,
+        orderBy: [{ columnName: SPAN_KEYS.TIMESTAMP, order: ORDER_DIRECTIONS.DESC }],
+        offset: QUERY_DEFAULTS.OFFSET,
+        disabled: QUERY_DEFAULTS.DISABLED,
+        having: QUERY_DEFAULTS.HAVING,
+        legend: QUERY_DEFAULTS.LEGEND,
+        limit: QUERY_DEFAULTS.LIMIT_UNLIMITED,
+      };
+
+      const userMessagesFilters = buildBaseFilters();
+      userMessagesFilters.push({
+        key: {
+          key: SPAN_KEYS.MESSAGE_CONTENT,
+          ...QUERY_FIELD_CONFIGS.STRING_TAG,
+        },
+        op: OPERATORS.EXISTS,
+        value: '',
+      });
+
+      builderQueries.userMessages = {
+        dataSource: DATA_SOURCES.TRACES,
+        queryName: QUERY_EXPRESSIONS.USER_MESSAGES,
+        aggregateOperator: AGGREGATE_OPERATORS.MIN,
+        aggregateAttribute: {
+          key: SPAN_KEYS.TIMESTAMP,
+          ...QUERY_FIELD_CONFIGS.INT64_TAG_COLUMN,
+        },
+        filters: { op: OPERATORS.AND, items: userMessagesFilters },
+        groupBy: [
+          {
+            key: SPAN_KEYS.CONVERSATION_ID,
+            ...QUERY_FIELD_CONFIGS.STRING_TAG,
+          },
+          {
+            key: SPAN_KEYS.MESSAGE_CONTENT,
+            ...QUERY_FIELD_CONFIGS.STRING_TAG,
+          },
+        ],
+        expression: QUERY_EXPRESSIONS.USER_MESSAGES,
+        reduceTo: REDUCE_OPERATIONS.MIN,
+        stepInterval: QUERY_DEFAULTS.STEP_INTERVAL,
+        orderBy: [{ columnName: SPAN_KEYS.TIMESTAMP, order: ORDER_DIRECTIONS.ASC }],
+        offset: QUERY_DEFAULTS.OFFSET,
+        disabled: QUERY_DEFAULTS.DISABLED,
+        having: QUERY_DEFAULTS.HAVING,
+        legend: QUERY_DEFAULTS.LEGEND,
+        limit: QUERY_DEFAULTS.LIMIT_UNLIMITED,
+      };
+    }
+
+    return {
+      start,
+      end,
+      step: QUERY_DEFAULTS.STEP,
+      variables: {},
+      compositeQuery: {
+        queryType: QUERY_TYPES.BUILDER,
+        panelType: PANEL_TYPES.TABLE,
+        builderQueries,
+      },
+      dataSource: DATA_SOURCES.TRACES,
+      projectId,
+    };
+  }
+
+  private buildFilteredConversationsPayload(
+    start: number,
+    end: number,
+    filters: SpanFilterOptions,
+    projectId?: string
+  ) {
+    const items: any[] = [
+      {
+        key: {
+          key: SPAN_KEYS.CONVERSATION_ID,
+          ...QUERY_FIELD_CONFIGS.STRING_TAG,
+        },
+        op: OPERATORS.EXISTS,
+        value: '',
+      },
+    ];
+
+    if (filters.spanName) {
+      items.push({
+        key: { key: SPAN_KEYS.NAME, ...QUERY_FIELD_CONFIGS.STRING_TAG_COLUMN },
+        op: OPERATORS.EQUALS,
+        value: filters.spanName,
+      });
+    }
+
+    // Attribute filters — pass typed booleans/numbers where possible
+    for (const attr of filters.attributes ?? []) {
+      const op = attr.operator ?? OPERATORS.EQUALS;
+      let value: any = asTypedFilterValue(attr.value);
+      let dataType: 'string' | 'int64' | 'float64' | 'bool' = 'string';
+      if (typeof value === 'boolean') dataType = 'bool';
+      else if (typeof value === 'number') dataType = Number.isInteger(value) ? 'int64' : 'float64';
+
+      // exists/nexists ignore value
+      if (op === OPERATORS.EXISTS || op === OPERATORS.NOT_EXISTS) {
+        items.push({
+          key: { key: attr.key, ...QUERY_FIELD_CONFIGS.STRING_TAG },
+          op,
+          value: '',
+        });
+        continue;
+      }
+
+      // LIKE operators add wildcards if absent
+      if (
+        (op === OPERATORS.LIKE || op === OPERATORS.NOT_LIKE) &&
+        typeof value === 'string' &&
+        !value.includes('%')
+      ) {
+        value = `%${value}%`;
+      }
+
+      // For numeric equality, keep exact-match pair (>= & <=) for robustness
+      if ((dataType === 'int64' || dataType === 'float64') && op === OPERATORS.EQUALS) {
+        const config =
+          dataType === 'int64' ? QUERY_FIELD_CONFIGS.INT64_TAG : QUERY_FIELD_CONFIGS.FLOAT64_TAG;
+        items.push({
+          key: { key: attr.key, ...config },
+          op: OPERATORS.GREATER_THAN_OR_EQUAL,
+          value,
+        });
+        items.push({
+          key: { key: attr.key, ...config },
+          op: OPERATORS.LESS_THAN_OR_EQUAL,
+          value,
+        });
+      } else {
+        const config =
+          dataType === 'string'
+            ? QUERY_FIELD_CONFIGS.STRING_TAG
+            : dataType === 'int64'
+              ? QUERY_FIELD_CONFIGS.INT64_TAG
+              : dataType === 'float64'
+                ? QUERY_FIELD_CONFIGS.FLOAT64_TAG
+                : QUERY_FIELD_CONFIGS.BOOL_TAG;
+        items.push({ key: { key: attr.key, ...config }, op, value });
+      }
+    }
+
+    if (projectId) {
+      items.push({
+        key: { key: SPAN_KEYS.PROJECT_ID, ...QUERY_FIELD_CONFIGS.STRING_TAG },
+        op: OPERATORS.EQUALS,
+        value: projectId,
+      });
+    }
+
+    return {
       start,
       end,
       step: QUERY_DEFAULTS.STEP,
@@ -1266,12 +1661,297 @@ class SigNozStatsAPI {
     };
   }
 
+  private buildAggregateBadgesPayload(
+    start: number,
+    end: number,
+    projectId?: string,
+    agentId?: string,
+    conversationIds?: string[]
+  ) {
+    const buildBaseFilters = (): any[] => {
+      const items: any[] = [];
+
+      if (projectId) {
+        items.push({
+          key: {
+            key: SPAN_KEYS.PROJECT_ID,
+            ...QUERY_FIELD_CONFIGS.STRING_TAG,
+          },
+          op: OPERATORS.EQUALS,
+          value: projectId,
+        });
+      }
+
+      if (agentId) {
+        items.push({
+          key: {
+            key: SPAN_KEYS.AGENT_ID,
+            ...QUERY_FIELD_CONFIGS.STRING_TAG,
+          },
+          op: OPERATORS.EQUALS,
+          value: agentId,
+        });
+      }
+      return items;
+    };
+
+    const buildConversationIdFilter = (): any[] => {
+      if (conversationIds && conversationIds.length > 0) {
+        return [
+          {
+            key: {
+              key: SPAN_KEYS.CONVERSATION_ID,
+              ...QUERY_FIELD_CONFIGS.STRING_TAG,
+            },
+            op: OPERATORS.IN,
+            value: conversationIds,
+          },
+        ];
+      }
+      return [
+        {
+          key: {
+            key: SPAN_KEYS.CONVERSATION_ID,
+            ...QUERY_FIELD_CONFIGS.STRING_TAG,
+          },
+          op: OPERATORS.EXISTS,
+          value: '',
+        },
+      ];
+    };
+
+    const baseFilters = buildBaseFilters();
+    const conversationIdFilters = buildConversationIdFilter();
+
+    return {
+      start,
+      end,
+      step: QUERY_DEFAULTS.STEP,
+      variables: {},
+      compositeQuery: {
+        queryType: QUERY_TYPES.BUILDER,
+        panelType: PANEL_TYPES.TABLE,
+        builderQueries: {
+          totalToolCalls: {
+            dataSource: DATA_SOURCES.TRACES,
+            queryName: 'totalToolCalls',
+            aggregateOperator: AGGREGATE_OPERATORS.COUNT,
+            aggregateAttribute: {
+              key: SPAN_KEYS.SPAN_ID,
+              ...QUERY_FIELD_CONFIGS.STRING_TAG_COLUMN,
+            },
+            filters: {
+              op: OPERATORS.AND,
+              items: [
+                ...baseFilters,
+                {
+                  key: {
+                    key: SPAN_KEYS.NAME,
+                    ...QUERY_FIELD_CONFIGS.STRING_TAG_COLUMN,
+                  },
+                  op: OPERATORS.EQUALS,
+                  value: SPAN_NAMES.AI_TOOL_CALL,
+                },
+                ...conversationIdFilters,
+                {
+                  key: {
+                    key: SPAN_KEYS.AI_TOOL_TYPE,
+                    ...QUERY_FIELD_CONFIGS.STRING_TAG,
+                  },
+                  op: OPERATORS.EQUALS,
+                  value: AI_TOOL_TYPES.MCP,
+                },
+              ],
+            },
+            groupBy: QUERY_DEFAULTS.EMPTY_GROUP_BY,
+            expression: 'totalToolCalls',
+            reduceTo: REDUCE_OPERATIONS.SUM,
+            stepInterval: QUERY_DEFAULTS.STEP_INTERVAL,
+            orderBy: [],
+            offset: QUERY_DEFAULTS.OFFSET,
+            disabled: QUERY_DEFAULTS.DISABLED,
+            having: QUERY_DEFAULTS.HAVING,
+            legend: QUERY_DEFAULTS.LEGEND,
+            limit: QUERY_DEFAULTS.LIMIT_UNLIMITED,
+          },
+
+          totalTransfers: {
+            dataSource: DATA_SOURCES.TRACES,
+            queryName: 'totalTransfers',
+            aggregateOperator: AGGREGATE_OPERATORS.COUNT,
+            aggregateAttribute: {
+              key: SPAN_KEYS.SPAN_ID,
+              ...QUERY_FIELD_CONFIGS.STRING_TAG_COLUMN,
+            },
+            filters: {
+              op: OPERATORS.AND,
+              items: [
+                ...baseFilters,
+                {
+                  key: {
+                    key: SPAN_KEYS.NAME,
+                    ...QUERY_FIELD_CONFIGS.STRING_TAG_COLUMN,
+                  },
+                  op: OPERATORS.EQUALS,
+                  value: SPAN_NAMES.AI_TOOL_CALL,
+                },
+                {
+                  key: {
+                    key: SPAN_KEYS.AI_TOOL_TYPE,
+                    ...QUERY_FIELD_CONFIGS.STRING_TAG,
+                  },
+                  op: OPERATORS.EQUALS,
+                  value: AI_TOOL_TYPES.TRANSFER,
+                },
+                ...conversationIdFilters,
+              ],
+            },
+            groupBy: QUERY_DEFAULTS.EMPTY_GROUP_BY,
+            expression: 'totalTransfers',
+            reduceTo: REDUCE_OPERATIONS.SUM,
+            stepInterval: QUERY_DEFAULTS.STEP_INTERVAL,
+            orderBy: [],
+            offset: QUERY_DEFAULTS.OFFSET,
+            disabled: QUERY_DEFAULTS.DISABLED,
+            having: QUERY_DEFAULTS.HAVING,
+            legend: QUERY_DEFAULTS.LEGEND,
+            limit: QUERY_DEFAULTS.LIMIT_UNLIMITED,
+          },
+
+          totalDelegations: {
+            dataSource: DATA_SOURCES.TRACES,
+            queryName: 'totalDelegations',
+            aggregateOperator: AGGREGATE_OPERATORS.COUNT,
+            aggregateAttribute: {
+              key: SPAN_KEYS.SPAN_ID,
+              ...QUERY_FIELD_CONFIGS.STRING_TAG_COLUMN,
+            },
+            filters: {
+              op: OPERATORS.AND,
+              items: [
+                ...baseFilters,
+                {
+                  key: {
+                    key: SPAN_KEYS.NAME,
+                    ...QUERY_FIELD_CONFIGS.STRING_TAG_COLUMN,
+                  },
+                  op: OPERATORS.EQUALS,
+                  value: SPAN_NAMES.AI_TOOL_CALL,
+                },
+                {
+                  key: {
+                    key: SPAN_KEYS.AI_TOOL_TYPE,
+                    ...QUERY_FIELD_CONFIGS.STRING_TAG,
+                  },
+                  op: OPERATORS.EQUALS,
+                  value: AI_TOOL_TYPES.DELEGATION,
+                },
+                ...conversationIdFilters,
+              ],
+            },
+            groupBy: QUERY_DEFAULTS.EMPTY_GROUP_BY,
+            expression: 'totalDelegations',
+            reduceTo: REDUCE_OPERATIONS.SUM,
+            stepInterval: QUERY_DEFAULTS.STEP_INTERVAL,
+            orderBy: [],
+            offset: QUERY_DEFAULTS.OFFSET,
+            disabled: QUERY_DEFAULTS.DISABLED,
+            having: QUERY_DEFAULTS.HAVING,
+            legend: QUERY_DEFAULTS.LEGEND,
+            limit: QUERY_DEFAULTS.LIMIT_UNLIMITED,
+          },
+
+          totalAICalls: {
+            dataSource: DATA_SOURCES.TRACES,
+            queryName: 'totalAICalls',
+            aggregateOperator: AGGREGATE_OPERATORS.COUNT,
+            aggregateAttribute: {
+              key: SPAN_KEYS.SPAN_ID,
+              ...QUERY_FIELD_CONFIGS.STRING_TAG_COLUMN,
+            },
+            filters: {
+              op: OPERATORS.AND,
+              items: [
+                ...baseFilters,
+                {
+                  key: {
+                    key: SPAN_KEYS.AI_OPERATION_ID,
+                    ...QUERY_FIELD_CONFIGS.STRING_TAG,
+                  },
+                  op: OPERATORS.EQUALS,
+                  value: AI_OPERATIONS.GENERATE_TEXT,
+                },
+                ...conversationIdFilters,
+              ],
+            },
+            groupBy: QUERY_DEFAULTS.EMPTY_GROUP_BY,
+            expression: 'totalAICalls',
+            reduceTo: REDUCE_OPERATIONS.SUM,
+            stepInterval: QUERY_DEFAULTS.STEP_INTERVAL,
+            orderBy: [],
+            offset: QUERY_DEFAULTS.OFFSET,
+            disabled: QUERY_DEFAULTS.DISABLED,
+            having: QUERY_DEFAULTS.HAVING,
+            legend: QUERY_DEFAULTS.LEGEND,
+            limit: QUERY_DEFAULTS.LIMIT_UNLIMITED,
+          },
+
+          totalConversations: {
+            dataSource: DATA_SOURCES.TRACES,
+            queryName: 'totalConversations',
+            aggregateOperator: AGGREGATE_OPERATORS.COUNT_DISTINCT,
+            aggregateAttribute: {
+              key: SPAN_KEYS.CONVERSATION_ID,
+              ...QUERY_FIELD_CONFIGS.STRING_TAG,
+            },
+            filters: {
+              op: OPERATORS.AND,
+              items: [
+                ...baseFilters,
+                ...conversationIdFilters,
+                {
+                  key: {
+                    key: SPAN_KEYS.TENANT_ID,
+                    ...QUERY_FIELD_CONFIGS.STRING_TAG,
+                  },
+                  op: OPERATORS.EXISTS,
+                  value: '',
+                },
+                {
+                  key: {
+                    key: SPAN_KEYS.AGENT_ID,
+                    ...QUERY_FIELD_CONFIGS.STRING_TAG,
+                  },
+                  op: OPERATORS.EXISTS,
+                  value: '',
+                },
+              ],
+            },
+            groupBy: QUERY_DEFAULTS.EMPTY_GROUP_BY,
+            expression: 'totalConversations',
+            reduceTo: REDUCE_OPERATIONS.SUM,
+            stepInterval: QUERY_DEFAULTS.STEP_INTERVAL,
+            orderBy: [],
+            offset: QUERY_DEFAULTS.OFFSET,
+            disabled: QUERY_DEFAULTS.DISABLED,
+            having: QUERY_DEFAULTS.HAVING,
+            legend: QUERY_DEFAULTS.LEGEND,
+            limit: QUERY_DEFAULTS.LIMIT_UNLIMITED,
+          },
+        },
+      },
+      dataSource: DATA_SOURCES.TRACES,
+      projectId,
+    };
+  }
+
   private buildCombinedPayload(
     start: number,
     end: number,
     _filters?: SpanFilterOptions,
     projectId?: string,
-    agentId?: string
+    agentId?: string,
+    conversationIds?: string[]
   ) {
     const withProjectAndAgent = (items: any[]) => {
       let filtered = items;
@@ -1301,6 +1981,33 @@ class SigNozStatsAPI {
           },
         ];
       }
+      // Add conversation ID filters if provided (for pagination optimization)
+      if (conversationIds && conversationIds.length > 0) {
+        filtered = [
+          ...filtered,
+          {
+            key: {
+              key: SPAN_KEYS.CONVERSATION_ID,
+              ...QUERY_FIELD_CONFIGS.STRING_TAG,
+            },
+            op: OPERATORS.IN,
+            value: conversationIds,
+          },
+        ];
+      } else {
+        // Only add EXISTS check if no specific IDs provided
+        filtered = [
+          ...filtered,
+          {
+            key: {
+              key: SPAN_KEYS.CONVERSATION_ID,
+              ...QUERY_FIELD_CONFIGS.STRING_TAG,
+            },
+            op: OPERATORS.EXISTS,
+            value: '',
+          },
+        ];
+      }
       return filtered;
     };
 
@@ -1332,14 +2039,6 @@ class SigNozStatsAPI {
                   op: OPERATORS.EQUALS,
                   value: SPAN_NAMES.AI_TOOL_CALL,
                 },
-                {
-                  key: {
-                    key: SPAN_KEYS.CONVERSATION_ID,
-                    ...QUERY_FIELD_CONFIGS.STRING_TAG,
-                  },
-                  op: OPERATORS.EXISTS,
-                  value: '',
-                },
                 {
                   key: {
                     key: SPAN_KEYS.AI_TOOL_TYPE,
@@ -1398,14 +2097,6 @@ class SigNozStatsAPI {
                   op: OPERATORS.EQUALS,
                   value: AI_TOOL_TYPES.TRANSFER,
                 },
-                {
-                  key: {
-                    key: SPAN_KEYS.CONVERSATION_ID,
-                    ...QUERY_FIELD_CONFIGS.STRING_TAG,
-                  },
-                  op: OPERATORS.EXISTS,
-                  value: '',
-                },
               ]),
             },
             groupBy: [
@@ -1460,14 +2151,6 @@ class SigNozStatsAPI {
                   op: OPERATORS.EQUALS,
                   value: AI_TOOL_TYPES.DELEGATION,
                 },
-                {
-                  key: {
-                    key: SPAN_KEYS.CONVERSATION_ID,
-                    ...QUERY_FIELD_CONFIGS.STRING_TAG,
-                  },
-                  op: OPERATORS.EXISTS,
-                  value: '',
-                },
               ]),
             },
             groupBy: [
@@ -1506,14 +2189,6 @@ class SigNozStatsAPI {
             filters: {
               op: OPERATORS.AND,
               items: withProjectAndAgent([
-                {
-                  key: {
-                    key: SPAN_KEYS.CONVERSATION_ID,
-                    ...QUERY_FIELD_CONFIGS.STRING_TAG,
-                  },
-                  op: OPERATORS.EXISTS,
-                  value: '',
-                },
                 {
                   key: {
                     key: SPAN_KEYS.TENANT_ID,
@@ -1571,14 +2246,6 @@ class SigNozStatsAPI {
                   op: OPERATORS.EQUALS,
                   value: AI_OPERATIONS.GENERATE_TEXT,
                 },
-                {
-                  key: {
-                    key: SPAN_KEYS.CONVERSATION_ID,
-                    ...QUERY_FIELD_CONFIGS.STRING_TAG,
-                  },
-                  op: OPERATORS.EXISTS,
-                  value: '',
-                },
               ]),
             },
             groupBy: [
@@ -1613,16 +2280,7 @@ class SigNozStatsAPI {
             },
             filters: {
               op: OPERATORS.AND,
-              items: withProjectAndAgent([
-                {
-                  key: {
-                    key: SPAN_KEYS.CONVERSATION_ID,
-                    ...QUERY_FIELD_CONFIGS.STRING_TAG,
-                  },
-                  op: OPERATORS.EXISTS,
-                  value: '',
-                },
-              ]),
+              items: withProjectAndAgent([]),
             },
             groupBy: [
               {
@@ -1660,14 +2318,6 @@ class SigNozStatsAPI {
                   op: OPERATORS.EQUALS,
                   value: true,
                 },
-                {
-                  key: {
-                    key: SPAN_KEYS.CONVERSATION_ID,
-                    ...QUERY_FIELD_CONFIGS.STRING_TAG,
-                  },
-                  op: OPERATORS.EXISTS,
-                  value: '',
-                },
               ]),
             },
             groupBy: [
@@ -1710,14 +2360,6 @@ class SigNozStatsAPI {
                   op: OPERATORS.EXISTS,
                   value: '',
                 },
-                {
-                  key: {
-                    key: SPAN_KEYS.CONVERSATION_ID,
-                    ...QUERY_FIELD_CONFIGS.STRING_TAG,
-                  },
-                  op: OPERATORS.EXISTS,
-                  value: '',
-                },
               ]),
             },
             groupBy: [