@memberjunction/ng-dashboards 5.21.0 → 5.23.0

package/dist/AI/services/ai-instrumentation.service.js

@@ -1,8 +1,19 @@
 import { Injectable } from '@angular/core';
 import { BehaviorSubject, from, combineLatest } from 'rxjs';
-import { switchMap, shareReplay, tap } from 'rxjs/operators';
-import { RunView, Metadata } from '@memberjunction/core';
+import { switchMap, shareReplay, tap, map } from 'rxjs/operators';
+import { RunView } from '@memberjunction/core';
 import * as i0 from "@angular/core";
+/** Fields to request for prompt runs — only what the dashboard needs for aggregation */
+const PROMPT_RUN_FIELDS = [
+    'ID', 'RunAt', 'CompletedAt', 'Success', 'Cost', 'TokensUsed',
+    'TokensPrompt', 'TokensCompletion', 'ExecutionTimeMS',
+    'ModelID', 'Model', 'AgentID', 'Agent', 'Prompt', 'ErrorMessage'
+];
+/** Fields to request for agent runs — only what the dashboard needs for aggregation */
+const AGENT_RUN_FIELDS = [
+    'ID', 'StartedAt', 'CompletedAt', 'Status', 'Success',
+    'TotalCost', 'TotalTokensUsed', 'AgentID', 'Agent', 'ErrorMessage'
+];
 export class AIInstrumentationService {
     _dateRange$ = new BehaviorSubject({
         start: new Date(Date.now() - 24 * 60 * 60 * 1000), // Last 24 hours
@@ -10,57 +21,77 @@ export class AIInstrumentationService {
     });
     _refreshTrigger$ = new BehaviorSubject(0);
     _isLoading$ = new BehaviorSubject(false);
-    metadata = new Metadata();
     // Expose loading state as observable
     isLoading$ = this._isLoading$.asObservable();
     constructor() { }
-    // Main data streams - trigger on refresh or date range change
-    kpis$ = combineLatest([this._refreshTrigger$, this._dateRange$]).pipe(tap(() => this._isLoading$.next(true)), switchMap(() => from(this.loadKPIs())), tap(() => this.checkLoadingComplete()), shareReplay(1));
-    trends$ = combineLatest([this._refreshTrigger$, this._dateRange$]).pipe(tap(() => this._isLoading$.next(true)), switchMap(() => from(this.loadTrends())), tap(() => this.checkLoadingComplete()), shareReplay(1));
-    liveExecutions$ = combineLatest([this._refreshTrigger$, this._dateRange$]).pipe(tap(() => this._isLoading$.next(true)), switchMap(() => from(this.loadLiveExecutions())), tap(() => this.checkLoadingComplete()), shareReplay(1));
-    chartData$ = combineLatest([this._refreshTrigger$, this._dateRange$]).pipe(tap(() => this._isLoading$.next(true)), switchMap(() => from(this.loadChartData())), tap(() => this.checkLoadingComplete()), shareReplay(1));
-    loadingCount = 0;
-    checkLoadingComplete() {
-        // Simple mechanism to track when all streams have completed
-        setTimeout(() => {
-            this._isLoading$.next(false);
-        }, 100);
-    }
+    /**
+     * Single data load: fetches prompt runs and agent runs ONCE per refresh/date-range change.
+     * All downstream streams derive from this shared dataset.
+     */
+    rawData$ = combineLatest([this._refreshTrigger$, this._dateRange$]).pipe(tap(() => this._isLoading$.next(true)), switchMap(() => from(this.loadAllData())), tap(() => this._isLoading$.next(false)), shareReplay(1));
+    // Derived streams — pure in-memory transforms, no extra DB queries
+    kpis$ = this.rawData$.pipe(map(data => this.computeKPIs(data.promptRuns, data.agentRuns)), shareReplay(1));
+    trends$ = this.rawData$.pipe(map(data => this.computeTrends(data.promptRuns, data.agentRuns)), shareReplay(1));
+    liveExecutions$ = this.rawData$.pipe(map(data => this.computeLiveExecutions(data.livePromptRuns, data.liveAgentRuns)), shareReplay(1));
+    chartData$ = combineLatest([this.rawData$, this.trends$]).pipe(map(([data, executionTrends]) => this.computeChartData(data.promptRuns, executionTrends)), shareReplay(1));
     setDateRange(start, end) {
         this._dateRange$.next({ start, end });
-        // No need to manually refresh - streams now react to date range changes
     }
     refresh() {
         this._refreshTrigger$.next(this._refreshTrigger$.value + 1);
     }
-    async loadKPIs() {
+    /**
+     * Single batch query that loads all data needed by every dashboard widget.
+     * Uses ResultType: 'simple' with explicit Fields to minimize payload size.
+     */
+    async loadAllData() {
         const { start, end } = this._dateRange$.value;
+        const now = new Date();
+        const recentTime = new Date(now.getTime() - 5 * 60 * 1000);
         const rv = new RunView();
-        // Use RunViews to batch the queries
-        const [promptResults, agentResults] = await rv.RunViews([
+        const [promptResults, agentResults, livePromptResults, liveAgentResults] = await rv.RunViews([
+            {
+                EntityName: 'MJ: AI Prompt Runs',
+                ExtraFilter: `RunAt >= '${start.toISOString()}' AND RunAt <= '${end.toISOString()}'`,
+                Fields: PROMPT_RUN_FIELDS,
+                ResultType: 'simple'
+            },
+            {
+                EntityName: 'MJ: AI Agent Runs',
+                ExtraFilter: `StartedAt >= '${start.toISOString()}' AND StartedAt <= '${end.toISOString()}'`,
+                Fields: AGENT_RUN_FIELDS,
+                ResultType: 'simple'
+            },
             {
                 EntityName: 'MJ: AI Prompt Runs',
-                ExtraFilter: `RunAt >= '${start.toISOString()}' AND RunAt <= '${end.toISOString()}'`
+                ExtraFilter: `RunAt >= '${recentTime.toISOString()}'`,
+                OrderBy: 'RunAt DESC',
+                Fields: PROMPT_RUN_FIELDS,
+                ResultType: 'simple'
             },
             {
                 EntityName: 'MJ: AI Agent Runs',
-                ExtraFilter: `StartedAt >= '${start.toISOString()}' AND StartedAt <= '${end.toISOString()}'`
+                ExtraFilter: `StartedAt >= '${recentTime.toISOString()}'`,
+                OrderBy: 'StartedAt DESC',
+                Fields: AGENT_RUN_FIELDS,
+                ResultType: 'simple'
             }
         ]);
-        const promptRuns = promptResults.Results;
-        const agentRuns = agentResults.Results;
-        // Calculate KPIs
+        return {
+            promptRuns: promptResults.Results,
+            agentRuns: agentResults.Results,
+            livePromptRuns: livePromptResults.Results,
+            liveAgentRuns: liveAgentResults.Results
+        };
+    }
+    // ─── KPI Computation ─────────────────────────────────────────────
+    computeKPIs(promptRuns, agentRuns) {
         const totalExecutions = promptRuns.length + agentRuns.length;
         const activeExecutions = this.countActiveExecutions(promptRuns, agentRuns);
         const totalCost = this.sumCosts(promptRuns, agentRuns);
         const totalTokens = this.sumTokens(promptRuns, agentRuns);
         const avgExecutionTime = this.calculateAverageExecutionTime(promptRuns, agentRuns);
         const successRate = this.calculateSuccessRate(promptRuns, agentRuns);
-        const errorRate = 1 - successRate;
-        const costPerToken = totalTokens > 0 ? totalCost / totalTokens : 0;
-        const dailyCostBurn = this.calculateDailyCostBurn(promptRuns, agentRuns);
-        const topModel = await this.getTopModel(promptRuns);
-        const topAgent = await this.getTopAgent(agentRuns);
         return {
             totalExecutions,
             activeExecutions,
@@ -69,118 +100,71 @@ export class AIInstrumentationService {
             avgExecutionTime,
             successRate,
             totalTokens,
-            costPerToken,
-            topModel,
-            topAgent,
-            errorRate,
-            dailyCostBurn
+            costPerToken: totalTokens > 0 ? totalCost / totalTokens : 0,
+            topModel: this.getTopModel(promptRuns),
+            topAgent: this.getTopAgent(agentRuns),
+            errorRate: 1 - successRate,
+            dailyCostBurn: this.calculateDailyCostBurn(promptRuns, agentRuns)
         };
     }
-    async loadTrends() {
+    // ─── Trend Computation ────────────────────────────────────────────
+    computeTrends(promptRuns, agentRuns) {
         const { start, end } = this._dateRange$.value;
+        const bucketSizeMs = this.getBucketSizeMs(start, end);
         const hourlyBuckets = this.createHourlyBuckets(start, end);
-        // Calculate bucket size based on the number of buckets
-        const duration = end.getTime() - start.getTime();
-        const hours = duration / (1000 * 60 * 60);
-        let bucketSizeMs;
-        if (hours <= 24) {
-            bucketSizeMs = 60 * 60 * 1000; // 1 hour
-        }
-        else if (hours <= 24 * 7) {
-            bucketSizeMs = 4 * 60 * 60 * 1000; // 4 hours
-        }
-        else {
-            bucketSizeMs = 24 * 60 * 60 * 1000; // 24 hours
-        }
-        // Load all data in a single query instead of per-bucket
-        const rv = new RunView();
-        const [promptResults, agentResults] = await rv.RunViews([
-            {
-                EntityName: 'MJ: AI Prompt Runs',
-                ExtraFilter: `RunAt >= '${start.toISOString()}' AND RunAt <= '${end.toISOString()}'`
-            },
-            {
-                EntityName: 'MJ: AI Agent Runs',
-                ExtraFilter: `StartedAt >= '${start.toISOString()}' AND StartedAt <= '${end.toISOString()}'`
-            }
-        ]);
-        const allPromptRuns = promptResults.Results;
-        const allAgentRuns = agentResults.Results;
-        // Now aggregate data into buckets on the client side
-        const trends = [];
-        for (const bucket of hourlyBuckets) {
-            const bucketStart = bucket;
+        return hourlyBuckets.map(bucket => {
             const bucketEnd = new Date(bucket.getTime() + bucketSizeMs);
-            // Filter runs for this bucket
-            const promptRuns = allPromptRuns.filter(r => {
+            const bucketPrompts = promptRuns.filter(r => {
                 const runAt = new Date(r.RunAt);
-                return runAt >= bucketStart && runAt < bucketEnd;
+                return runAt >= bucket && runAt < bucketEnd;
             });
-            const agentRuns = allAgentRuns.filter(r => {
+            const bucketAgents = agentRuns.filter(r => {
                 const startedAt = new Date(r.StartedAt);
-                return startedAt >= bucketStart && startedAt < bucketEnd;
+                return startedAt >= bucket && startedAt < bucketEnd;
             });
-            trends.push({
+            return {
                 timestamp: bucket,
-                executions: promptRuns.length + agentRuns.length,
-                cost: this.sumCosts(promptRuns, agentRuns),
-                tokens: this.sumTokens(promptRuns, agentRuns),
-                avgTime: this.calculateAverageExecutionTime(promptRuns, agentRuns),
-                errors: this.countErrors(promptRuns, agentRuns)
-            });
-        }
-        return trends;
+                executions: bucketPrompts.length + bucketAgents.length,
+                cost: this.sumCosts(bucketPrompts, bucketAgents),
+                tokens: this.sumTokens(bucketPrompts, bucketAgents),
+                avgTime: this.calculateAverageExecutionTime(bucketPrompts, bucketAgents),
+                errors: this.countErrors(bucketPrompts, bucketAgents)
+            };
+        });
     }
-    async loadLiveExecutions() {
+    // ─── Live Executions Computation ──────────────────────────────────
+    computeLiveExecutions(promptRuns, agentRuns) {
         const now = new Date();
-        const recentTime = new Date(now.getTime() - 5 * 60 * 1000);
-        const rv = new RunView();
-        const [promptResults, agentResults] = await rv.RunViews([
-            {
-                EntityName: 'MJ: AI Prompt Runs',
-                ExtraFilter: `RunAt >= '${recentTime.toISOString()}'`,
-                OrderBy: 'RunAt DESC'
-            },
-            {
-                EntityName: 'MJ: AI Agent Runs',
-                ExtraFilter: `StartedAt >= '${recentTime.toISOString()}'`,
-                OrderBy: 'StartedAt DESC'
-            }
-        ]);
-        const promptRuns = promptResults.Results;
-        const agentRuns = agentResults.Results;
         const liveExecutions = [];
-        // Process prompt runs - they already have the prompt name in the Prompt field
         for (const run of promptRuns) {
             const isRunning = !run.CompletedAt && run.Success !== false;
-            const duration = run.CompletedAt ?
-                new Date(run.CompletedAt).getTime() - new Date(run.RunAt).getTime() :
-                now.getTime() - new Date(run.RunAt).getTime();
+            const duration = run.CompletedAt
+                ? new Date(run.CompletedAt).getTime() - new Date(run.RunAt).getTime()
+                : now.getTime() - new Date(run.RunAt).getTime();
             liveExecutions.push({
                 id: run.ID,
                 type: 'prompt',
-                name: run.Prompt || 'Unnamed Prompt', // Use the Prompt field directly
+                name: run.Prompt || 'Unnamed Prompt',
                 status: isRunning ? 'running' : (run.Success ? 'completed' : 'failed'),
                 startTime: new Date(run.RunAt),
-                duration: duration,
+                duration,
                 cost: run.Cost || 0,
                 tokens: run.TokensUsed || 0,
                 progress: isRunning ? Math.min(90, (duration / 30000) * 100) : 100
             });
         }
-        // Process agent runs - they already have the agent name in the Agent field
         for (const run of agentRuns) {
             const isRunning = run.Status === 'Running';
-            const duration = run.CompletedAt ?
-                new Date(run.CompletedAt).getTime() - new Date(run.StartedAt).getTime() :
-                now.getTime() - new Date(run.StartedAt).getTime();
+            const duration = run.CompletedAt
+                ? new Date(run.CompletedAt).getTime() - new Date(run.StartedAt).getTime()
+                : now.getTime() - new Date(run.StartedAt).getTime();
             liveExecutions.push({
                 id: run.ID,
                 type: 'agent',
-                name: run.Agent || 'Unnamed Agent', // Use the Agent field directly
+                name: run.Agent || 'Unnamed Agent',
                 status: run.Status.toLowerCase(),
                 startTime: new Date(run.StartedAt),
-                duration: duration,
+                duration,
                 cost: run.TotalCost || 0,
                 tokens: run.TotalTokensUsed || 0,
                 progress: isRunning ? Math.min(90, (duration / 60000) * 100) : 100
@@ -188,27 +172,16 @@ export class AIInstrumentationService {
         }
         return liveExecutions.sort((a, b) => b.startTime.getTime() - a.startTime.getTime());
     }
-    async loadChartData() {
-        const { start, end } = this._dateRange$.value;
-        const dateFilter = `RunAt >= '${start.toISOString()}' AND RunAt <= '${end.toISOString()}'`;
-        const promptRv = new RunView();
-        const promptResults = await promptRv.RunView({
-            EntityName: 'MJ: AI Prompt Runs',
-            ExtraFilter: dateFilter
-        });
-        const promptRuns = promptResults.Results;
-        const executionTrends = await this.loadTrends();
-        const costByModel = await this.analyzeCostByModel(promptRuns);
-        const performanceMatrix = await this.analyzePerformanceMatrix(promptRuns);
-        const tokenEfficiency = await this.analyzeTokenEfficiency(promptRuns);
+    // ─── Chart Data Computation ───────────────────────────────────────
+    computeChartData(promptRuns, executionTrends) {
         return {
             executionTrends,
-            costByModel,
-            performanceMatrix,
-            tokenEfficiency
+            costByModel: this.analyzeCostByModel(promptRuns),
+            performanceMatrix: this.analyzePerformanceMatrix(promptRuns),
+            tokenEfficiency: this.analyzeTokenEfficiency(promptRuns)
         };
     }
-    // Helper methods
+    // ─── Helper Methods ───────────────────────────────────────────────
     countActiveExecutions(promptRuns, agentRuns) {
         const activePrompts = promptRuns.filter(r => !r.CompletedAt && r.Success !== false).length;
         const activeAgents = agentRuns.filter(r => r.Status === 'Running').length;
@@ -254,25 +227,28 @@ export class AIInstrumentationService {
         const todayAgents = agentRuns.filter(r => new Date(r.StartedAt) >= dayStart);
         return this.sumCosts(todayPrompts, todayAgents);
     }
+    getBucketSizeMs(start, end) {
+        const hours = (end.getTime() - start.getTime()) / (1000 * 60 * 60);
+        if (hours <= 24)
+            return 60 * 60 * 1000; // 1 hour
+        if (hours <= 24 * 7)
+            return 4 * 60 * 60 * 1000; // 4 hours
+        return 24 * 60 * 60 * 1000; // 24 hours
+    }
     createHourlyBuckets(start, end) {
         const buckets = [];
         const current = new Date(start);
-        const duration = end.getTime() - start.getTime();
-        const hours = duration / (1000 * 60 * 60);
-        // Determine bucket size based on duration
+        const hours = (end.getTime() - start.getTime()) / (1000 * 60 * 60);
         let bucketSize;
         if (hours <= 24) {
-            // For up to 24 hours, use hourly buckets
             bucketSize = 1;
             current.setMinutes(0, 0, 0);
         }
         else if (hours <= 24 * 7) {
-            // For up to 7 days, use 4-hour buckets
             bucketSize = 4;
             current.setHours(Math.floor(current.getHours() / 4) * 4, 0, 0, 0);
         }
         else {
-            // For more than 7 days, use daily buckets
             bucketSize = 24;
             current.setHours(0, 0, 0, 0);
         }
@@ -282,14 +258,12 @@ export class AIInstrumentationService {
         }
         return buckets;
     }
-    async getTopModel(promptRuns) {
+    getTopModel(promptRuns) {
         const modelCounts = new Map();
         const modelNames = new Map();
-        // Count models and track their names from the Model field
         for (const run of promptRuns) {
             if (run.ModelID && run.Model) {
-                const count = modelCounts.get(run.ModelID) || 0;
-                modelCounts.set(run.ModelID, count + 1);
+                modelCounts.set(run.ModelID, (modelCounts.get(run.ModelID) || 0) + 1);
                 modelNames.set(run.ModelID, run.Model);
             }
         }
@@ -299,14 +273,12 @@ export class AIInstrumentationService {
             .sort(([, a], [, b]) => b - a)[0][0];
         return modelNames.get(topModelId) || 'Unknown Model';
     }
-    async getTopAgent(agentRuns) {
+    getTopAgent(agentRuns) {
         const agentCounts = new Map();
         const agentNames = new Map();
-        // Count agents and track their names from the Agent field
         for (const run of agentRuns) {
             if (run.AgentID && run.Agent) {
-                const count = agentCounts.get(run.AgentID) || 0;
-                agentCounts.set(run.AgentID, count + 1);
+                agentCounts.set(run.AgentID, (agentCounts.get(run.AgentID) || 0) + 1);
                 agentNames.set(run.AgentID, run.Agent);
             }
         }
@@ -316,7 +288,7 @@ export class AIInstrumentationService {
             .sort(([, a], [, b]) => b - a)[0][0];
         return agentNames.get(topAgentId) || 'Unknown Agent';
     }
-    async analyzeCostByModel(promptRuns) {
+    analyzeCostByModel(promptRuns) {
         const modelStats = new Map();
         for (const run of promptRuns) {
             if (run.ModelID && run.Model) {
@@ -326,25 +298,17 @@ export class AIInstrumentationService {
                 modelStats.set(run.ModelID, existing);
             }
         }
-        const results = [];
-        for (const [modelId, stats] of modelStats.entries()) {
-            results.push({
-                model: stats.name,
-                cost: stats.cost,
-                tokens: stats.tokens
-            });
-        }
-        return results.sort((a, b) => b.cost - a.cost);
+        return Array.from(modelStats.values())
+            .map(stats => ({ model: stats.name, cost: stats.cost, tokens: stats.tokens }))
+            .sort((a, b) => b.cost - a.cost);
     }
-    async analyzePerformanceMatrix(promptRuns) {
+    analyzePerformanceMatrix(promptRuns) {
         const combinations = new Map();
         for (const run of promptRuns) {
             if (run.AgentID && run.ModelID && run.ExecutionTimeMS) {
                 const key = `${run.AgentID}:${run.ModelID}`;
                 const existing = combinations.get(key) || {
-                    times: [],
-                    successes: 0,
-                    total: 0,
+                    times: [], successes: 0, total: 0,
                     agentName: run.Agent || 'Unknown Agent',
                     modelName: run.Model || 'Unknown Model'
                 };
@@ -355,18 +319,14 @@ export class AIInstrumentationService {
                 combinations.set(key, existing);
             }
         }
-        const results = [];
-        for (const [key, data] of combinations.entries()) {
-            results.push({
-                agent: data.agentName,
-                model: data.modelName,
-                avgTime: data.times.reduce((sum, time) => sum + time, 0) / data.times.length,
-                successRate: data.successes / data.total
-            });
-        }
-        return results;
+        return Array.from(combinations.values()).map(data => ({
+            agent: data.agentName,
+            model: data.modelName,
+            avgTime: data.times.reduce((sum, time) => sum + time, 0) / data.times.length,
+            successRate: data.successes / data.total
+        }));
     }
-    async analyzeTokenEfficiency(promptRuns) {
+    analyzeTokenEfficiency(promptRuns) {
         const modelEfficiency = new Map();
         for (const run of promptRuns) {
             if (run.ModelID && run.Model && run.TokensPrompt && run.TokensCompletion) {
@@ -377,17 +337,14 @@ export class AIInstrumentationService {
                 modelEfficiency.set(run.ModelID, existing);
             }
         }
-        const results = [];
-        for (const [modelId, data] of modelEfficiency.entries()) {
-            results.push({
-                inputTokens: data.input,
-                outputTokens: data.output,
-                cost: data.cost,
-                model: data.name
-            });
-        }
-        return results;
+        return Array.from(modelEfficiency.values()).map(data => ({
+            inputTokens: data.input,
+            outputTokens: data.output,
+            cost: data.cost,
+            model: data.name
+        }));
     }
+    // ─── Execution Details (on-demand, not part of initial load) ──────
     async getExecutionDetails(executionId, type) {
         try {
             if (type === 'prompt') {
@@ -404,17 +361,23 @@ export class AIInstrumentationService {
     }
     async getPromptExecutionDetails(promptRunId) {
         const rv = new RunView();
-        const result = await rv.RunView({
-            EntityName: 'MJ: AI Prompt Runs',
-            ExtraFilter: `ID = '${promptRunId}'`
-        });
+        const [result, childrenResult] = await rv.RunViews([
+            {
+                EntityName: 'MJ: AI Prompt Runs',
+                ExtraFilter: `ID = '${promptRunId}'`,
+                Fields: PROMPT_RUN_FIELDS,
+                ResultType: 'simple'
+            },
+            {
+                EntityName: 'MJ: AI Prompt Runs',
+                ExtraFilter: `ParentID = '${promptRunId}'`,
+                Fields: PROMPT_RUN_FIELDS,
+                ResultType: 'simple'
+            }
+        ]);
         const run = result.Results[0];
         if (!run)
             throw new Error('Prompt run not found');
-        const childrenResult = await rv.RunView({
-            EntityName: 'MJ: AI Prompt Runs',
-            ExtraFilter: `ParentID = '${promptRunId}'`
-        });
         const children = await Promise.all(childrenResult.Results.map(child => this.getPromptExecutionDetails(child.ID)));
         return {
             id: run.ID,
@@ -427,24 +390,29 @@ export class AIInstrumentationService {
             tokens: run.TokensUsed || 0,
             success: run.Success || false,
             errorMessage: run.ErrorMessage || undefined,
-            parentId: run.ParentID || undefined,
             children,
             model: run.Model || undefined
         };
     }
     async getAgentExecutionDetails(agentRunId) {
         const rv = new RunView();
-        const result = await rv.RunView({
-            EntityName: 'MJ: AI Agent Runs',
-            ExtraFilter: `ID = '${agentRunId}'`
-        });
+        const [result, childrenResult] = await rv.RunViews([
+            {
+                EntityName: 'MJ: AI Agent Runs',
+                ExtraFilter: `ID = '${agentRunId}'`,
+                Fields: AGENT_RUN_FIELDS,
+                ResultType: 'simple'
+            },
+            {
+                EntityName: 'MJ: AI Agent Runs',
+                ExtraFilter: `ParentRunID = '${agentRunId}'`,
+                Fields: AGENT_RUN_FIELDS,
+                ResultType: 'simple'
+            }
+        ]);
         const run = result.Results[0];
         if (!run)
             throw new Error('Agent run not found');
-        const childrenResult = await rv.RunView({
-            EntityName: 'MJ: AI Agent Runs',
-            ExtraFilter: `ParentRunID = '${agentRunId}'`
-        });
         const children = await Promise.all(childrenResult.Results.map(child => this.getAgentExecutionDetails(child.ID)));
         return {
             id: run.ID,
@@ -457,7 +425,7 @@ export class AIInstrumentationService {
             tokens: run.TotalTokensUsed || 0,
             success: run.Success || false,
             errorMessage: run.ErrorMessage || undefined,
-            parentId: run.ParentRunID || undefined,
+            parentId: undefined,
             children
         };
     }