@defai.digital/cli 13.3.1 → 13.4.0

package/dist/web/api.js

@@ -0,0 +1,1189 @@
+/**
+ * Web API Handler
+ *
+ * Provides REST API endpoints for the web dashboard.
+ * Wraps existing domain services to expose via HTTP.
+ */
+import * as os from 'node:os';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { DATA_DIR_NAME, AGENTS_FILENAME } from '@defai.digital/contracts';
+// Get the directory of this module (for finding bundled examples)
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+import { getProviderRegistry, getTraceStore, getSessionManager as getSharedSessionManager, } from '../bootstrap.js';
+import { createPersistentAgentRegistry, } from '@defai.digital/agent-domain';
+import { createWorkflowLoader, findWorkflowDir, } from '@defai.digital/workflow-engine';
+import { CLI_VERSION } from '../commands/help.js';
+// Workflow loader singleton
+let workflowLoader;
+let workflowLoaderPromise;
+/**
+ * Find the example workflows directory.
+ * Searches multiple locations to work correctly regardless of working directory:
+ * 1. Package's examples directory (for development/source)
+ * 2. Monorepo root (for pnpm workspace)
+ * 3. Relative to cwd as fallback (for backward compatibility)
+ *
+ * This is the same pattern used for agents (see shared-registry.ts)
+ */
+function getExampleWorkflowsDir() {
+    // Try development path first (when running from source repo)
+    // __dirname is packages/cli/src/web, so go up 4 levels to repo root
+    const devPath = path.join(__dirname, '..', '..', '..', '..', 'examples', 'workflows');
+    if (fs.existsSync(devPath)) {
+        return devPath;
+    }
+    // Try monorepo root (for pnpm workspace, when running from dist)
+    const monorepoPath = path.join(__dirname, '..', '..', '..', '..', '..', 'examples', 'workflows');
+    if (fs.existsSync(monorepoPath)) {
+        return monorepoPath;
+    }
+    // Try relative to cwd as fallback (for backward compatibility)
+    const cwdPath = findWorkflowDir(process.cwd());
+    if (cwdPath) {
+        return cwdPath;
+    }
+    // Return development path as default (most likely for dev workflow)
+    return devPath;
+}
+/**
+ * Get or create the workflow loader (thread-safe)
+ * Uses atomic promise assignment pattern for safety
+ */
+async function getWorkflowLoader() {
+    if (workflowLoader)
+        return workflowLoader;
+    if (!workflowLoaderPromise) {
+        // Assign promise immediately to prevent potential race conditions
+        workflowLoaderPromise = Promise.resolve().then(() => {
+            const workflowsDir = getExampleWorkflowsDir();
+            const loader = createWorkflowLoader({ workflowsDir });
+            workflowLoader = loader;
+            return loader;
+        });
+    }
+    return workflowLoaderPromise;
+}
+// Lazy singletons with Promise-based initialization to prevent race conditions
+let agentRegistry;
+let agentRegistryPromise;
+/**
+ * Get the global agent storage path (same as MCP server).
+ * Uses home directory for consistency across all AutomatosX components.
+ */
+function getGlobalAgentStoragePath() {
+    return path.join(os.homedir(), DATA_DIR_NAME, AGENTS_FILENAME);
+}
+/**
+ * Get the session manager from CLI bootstrap (shared instance)
+ * This ensures the web dashboard sees the same sessions as other CLI components
+ */
+function getSessionManager() {
+    return getSharedSessionManager();
+}
+/**
+ * Get or create the agent registry (thread-safe)
+ * Uses atomic promise assignment pattern for safety
+ */
+async function getAgentRegistry() {
+    if (agentRegistry)
+        return agentRegistry;
+    if (!agentRegistryPromise) {
+        // Assign promise immediately to prevent potential race conditions
+        agentRegistryPromise = Promise.resolve().then(() => {
+            const registry = createPersistentAgentRegistry({
+                storagePath: getGlobalAgentStoragePath(),
+            });
+            agentRegistry = registry;
+            return registry;
+        });
+    }
+    return agentRegistryPromise;
+}
+/**
+ * Create the API handler function
+ */
+export function createAPIHandler() {
+    return async (req, res) => {
+        const url = req.url ?? '';
+        const apiPath = url.replace('/api', '');
+        try {
+            let response;
+            // Check for parameterized routes first
+            const traceTreeMatch = apiPath.match(/^\/traces\/([a-f0-9-]+)\/tree$/i);
+            const traceDetailMatch = apiPath.match(/^\/traces\/([a-f0-9-]+)$/i);
+            const workflowDetailMatch = apiPath.match(/^\/workflows\/([a-z0-9-]+)$/i);
+            const providerHistoryMatch = apiPath.match(/^\/providers\/([a-z0-9-]+)\/history$/i);
+            const agentHistoryMatch = apiPath.match(/^\/agents\/([a-z0-9-_]+)\/history$/i);
+            const agentDetailMatch = apiPath.match(/^\/agents\/([a-z0-9-_]+)$/i);
+            const workflowEventsMatch = apiPath.match(/^\/workflows\/([a-z0-9-]+)\/events$/i);
+            const traceSearchMatch = apiPath.match(/^\/traces\/search\?(.*)$/i) || apiPath.match(/^\/traces\/search$/i);
+            // INV-TR-020 through INV-TR-024: Hierarchical trace tree endpoint
+            if (traceTreeMatch && traceTreeMatch[1]) {
+                const traceId = traceTreeMatch[1];
+                response = await handleTraceTree(traceId);
+            }
+            else if (traceDetailMatch && traceDetailMatch[1]) {
+                const traceId = traceDetailMatch[1];
+                response = await handleTraceDetail(traceId);
+            }
+            else if (workflowDetailMatch && workflowDetailMatch[1]) {
+                const workflowId = workflowDetailMatch[1];
+                response = await handleWorkflowDetail(workflowId);
+            }
+            else if (providerHistoryMatch && providerHistoryMatch[1]) {
+                const providerId = providerHistoryMatch[1];
+                response = await handleProviderHistory(providerId);
+            }
+            else if (agentHistoryMatch && agentHistoryMatch[1]) {
+                const agentId = agentHistoryMatch[1];
+                response = await handleAgentHistory(agentId);
+            }
+            else if (agentDetailMatch && agentDetailMatch[1]) {
+                const agentId = agentDetailMatch[1];
+                response = await handleAgentDetail(agentId);
+            }
+            else if (workflowEventsMatch && workflowEventsMatch[1]) {
+                const workflowId = workflowEventsMatch[1];
+                response = await handleWorkflowEvents(workflowId);
+            }
+            else if (traceSearchMatch) {
+                const queryString = traceSearchMatch[1] ?? '';
+                const params = new URLSearchParams(queryString);
+                const searchFilters = {};
+                const pId = params.get('providerId');
+                const aId = params.get('agentId');
+                const pType = params.get('type');
+                const pLimit = params.get('limit');
+                if (pId)
+                    searchFilters.providerId = pId;
+                if (aId)
+                    searchFilters.agentId = aId;
+                if (pType)
+                    searchFilters.type = pType;
+                if (pLimit)
+                    searchFilters.limit = parseInt(pLimit, 10);
+                response = await handleTraceSearch(searchFilters);
+            }
+            else {
+                // Static routes
+                switch (apiPath) {
+                    case '/status':
+                        response = await handleStatus();
+                        break;
+                    case '/providers':
+                        response = await handleProviders();
+                        break;
+                    case '/sessions':
+                        response = await handleSessions();
+                        break;
+                    case '/agents':
+                        response = await handleAgents();
+                        break;
+                    case '/traces':
+                        response = await handleTraces();
+                        break;
+                    case '/workflows':
+                        response = await handleWorkflows();
+                        break;
+                    case '/metrics':
+                        response = await handleMetrics();
+                        break;
+                    case '/health':
+                        response = { success: true, data: { status: 'ok', version: CLI_VERSION } };
+                        break;
+                    default:
+                        res.writeHead(404, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ success: false, error: 'Not found' }));
+                        return;
+                }
+            }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(response));
+        }
+        catch (error) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                success: false,
+                error: error instanceof Error ? error.message : 'Internal server error',
+            }));
+        }
+    };
+}
+/**
+ * Get full system status
+ */
+async function handleStatus() {
+    const [providers, sessions, agents, traces, metrics] = await Promise.all([
+        getProviderData(),
+        getSessionData(),
+        getAgentData(),
+        getTraceData(),
+        getMetricsData(),
+    ]);
+    // Determine health status
+    const healthyProviders = providers.filter(p => p.available).length;
+    const totalProviders = providers.length;
+    const healthStatus = totalProviders === 0 ? 'healthy' :
+        healthyProviders === totalProviders ? 'healthy' :
+            healthyProviders > 0 ? 'degraded' : 'unhealthy';
+    return {
+        success: true,
+        data: {
+            status: healthStatus,
+            version: CLI_VERSION,
+            uptime: formatUptime(process.uptime()),
+            providers,
+            sessions,
+            agents,
+            traces,
+            metrics,
+        },
+    };
+}
+/**
+ * Get provider status
+ */
+async function handleProviders() {
+    const providers = await getProviderData();
+    return { success: true, data: providers };
+}
+/**
+ * Get sessions
+ */
+async function handleSessions() {
+    const sessions = await getSessionData();
+    return { success: true, data: sessions };
+}
+/**
+ * Get agents
+ */
+async function handleAgents() {
+    const agents = await getAgentData();
+    return { success: true, data: agents };
+}
+/**
+ * Get agent detail with full profile including workflow
+ */
+async function handleAgentDetail(agentId) {
+    try {
+        const registry = await getAgentRegistry();
+        const agent = await registry.get(agentId);
+        if (!agent) {
+            return { success: false, error: `Agent not found: ${agentId}` };
+        }
+        // Get execution stats from traces
+        const traceStore = getTraceStore();
+        const traces = await traceStore.listTraces(100);
+        let executionCount = 0;
+        let successCount = 0;
+        let totalDurationMs = 0;
+        for (const trace of traces) {
+            const events = await traceStore.getTrace(trace.traceId);
+            const hasAgent = events.some(e => {
+                const ctx = e.context;
+                return ctx?.agentId === agentId;
+            });
+            if (hasAgent) {
+                executionCount++;
+                if (trace.status === 'success')
+                    successCount++;
+                if (trace.durationMs)
+                    totalDurationMs += trace.durationMs;
+            }
+        }
+        return {
+            success: true,
+            data: {
+                agentId: agent.agentId,
+                displayName: agent.displayName ?? agent.agentId,
+                description: agent.description,
+                version: agent.version,
+                role: agent.role,
+                team: agent.team,
+                enabled: agent.enabled,
+                capabilities: agent.capabilities ?? [],
+                tags: agent.tags ?? [],
+                systemPrompt: agent.systemPrompt,
+                workflow: agent.workflow?.map(step => ({
+                    stepId: step.stepId,
+                    name: step.name,
+                    type: step.type,
+                    config: step.config,
+                    dependencies: step.dependencies,
+                    condition: step.condition,
+                })) ?? [],
+                orchestration: agent.orchestration,
+                personality: agent.personality,
+                expertise: agent.expertise,
+                // Stats
+                stats: {
+                    executionCount,
+                    successRate: executionCount > 0 ? successCount / executionCount : 1.0,
+                    avgDurationMs: executionCount > 0 ? Math.round(totalDurationMs / executionCount) : 0,
+                },
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to fetch agent details',
+        };
+    }
+}
+/**
+ * Get traces
+ */
+async function handleTraces() {
+    const traces = await getTraceData();
+    return { success: true, data: traces };
+}
+/**
+ * Get metrics
+ */
+async function handleMetrics() {
+    const metrics = await getMetricsData();
+    return { success: true, data: metrics };
+}
+/**
+ * Get workflows list
+ */
+async function handleWorkflows() {
+    const workflows = await getWorkflowData();
+    return { success: true, data: workflows };
+}
+/**
+ * Get detailed trace with events - enhanced with input/output info
+ */
+async function handleTraceDetail(traceId) {
+    try {
+        const traceStore = getTraceStore();
+        const events = await traceStore.getTrace(traceId);
+        if (!events || events.length === 0) {
+            return { success: false, error: `Trace not found: ${traceId}` };
+        }
+        // Build timeline from events
+        const timeline = events.map(event => ({
+            eventId: event.eventId,
+            type: event.type,
+            timestamp: event.timestamp,
+            durationMs: event.durationMs,
+            status: event.status,
+            context: event.context,
+            payload: event.payload,
+        }));
+        // Derive trace metadata from events
+        const startEvent = events.find(e => e.type === 'run.start' || e.type === 'discussion.start');
+        const endEvent = events.find(e => e.type === 'run.end' || e.type === 'discussion.end');
+        const stepEvents = events.filter(e => e.type === 'step.end');
+        const errorEvents = events.filter(e => e.type === 'error');
+        // Extract detailed info from start event
+        const startPayload = startEvent?.payload;
+        const endPayload = endEvent?.payload;
+        const context = startEvent?.context;
+        // Determine command type and extract relevant info
+        const command = startPayload?.command;
+        // First try to detect from explicit command field
+        let commandType;
+        if (command?.includes('discuss')) {
+            commandType = 'discuss';
+        }
+        else if (command?.includes('agent') || command === 'agent') {
+            commandType = 'agent';
+        }
+        else if (command?.includes('call')) {
+            commandType = 'call';
+        }
+        else {
+            // Fallback: detect from context/payload fields when command is not set
+            const hasAgentId = context?.agentId || startPayload?.agentId;
+            const hasTopic = startPayload?.topic;
+            const hasPrompt = startPayload?.prompt;
+            commandType = hasAgentId ? 'agent' :
+                hasTopic ? 'discuss' :
+                    hasPrompt ? 'call' : 'unknown';
+        }
+        // Extract input/output based on command type
+        let input;
+        let output;
+        let provider;
+        let model;
+        if (commandType === 'call') {
+            provider = context?.provider;
+            model = context?.model;
+            input = {
+                prompt: startPayload?.prompt, // Full prompt content
+                promptLength: startPayload?.promptLength,
+                mode: startPayload?.mode,
+                hasSystemPrompt: startPayload?.hasSystemPrompt,
+            };
+            output = {
+                response: endPayload?.response, // Full response content
+                responseLength: endPayload?.responseLength,
+                success: endPayload?.success,
+                latencyMs: endPayload?.latencyMs,
+                usage: endPayload?.usage,
+            };
+        }
+        else if (commandType === 'discuss') {
+            input = {
+                topic: startPayload?.topic,
+                pattern: startPayload?.pattern,
+                providers: startPayload?.providers,
+                rounds: startPayload?.rounds,
+                recursive: startPayload?.recursive,
+            };
+            output = {
+                responses: endPayload?.responses, // Provider responses
+                consensusReached: endPayload?.consensusReached,
+                consensus: endPayload?.consensus, // Consensus metadata (method, agreementScore, etc.)
+                synthesis: endPayload?.synthesis, // Final synthesized text
+                rounds: endPayload?.rounds,
+                success: endPayload?.success,
+            };
+        }
+        else if (commandType === 'agent') {
+            const agentId = startPayload?.agentId;
+            // Support both 'task' (CLI) and 'input' (MCP) field names
+            const taskOrInput = startPayload?.task ?? startPayload?.input;
+            input = {
+                agentId,
+                task: taskOrInput,
+                command: startPayload?.command,
+            };
+            output = {
+                stepCount: endPayload?.stepCount,
+                result: endPayload?.result ?? endPayload?.output,
+                success: endPayload?.success,
+                error: endPayload?.error,
+            };
+        }
+        // Build workflow steps from step events with full details
+        const workflowSteps = stepEvents.map(step => {
+            const stepPayload = step.payload;
+            const stepContext = step.context;
+            return {
+                stepId: stepPayload?.stepId ?? stepContext?.stepId,
+                iteration: stepPayload?.iteration,
+                intent: stepPayload?.intent,
+                action: stepPayload?.action,
+                prompt: stepPayload?.prompt, // Full prompt for this step
+                response: stepPayload?.response, // Full response for this step
+                responseLength: stepPayload?.responseLength,
+                success: stepPayload?.success,
+                durationMs: step.durationMs,
+                latencyMs: stepPayload?.latencyMs,
+                provider: stepContext?.provider,
+                model: stepContext?.model,
+                output: stepPayload?.output,
+                error: stepPayload?.error,
+                timestamp: step.timestamp,
+            };
+        });
+        // Determine status from events
+        let status = 'pending';
+        if (endEvent) {
+            status = endPayload?.success === true ? 'success' : 'failure';
+        }
+        else if (startEvent) {
+            status = 'running';
+        }
+        if (errorEvents.length > 0 && status !== 'failure') {
+            status = 'failure';
+        }
+        // Calculate total duration
+        const durationMs = endEvent?.durationMs ??
+            (endEvent && startEvent ?
+                new Date(endEvent.timestamp).getTime() - new Date(startEvent.timestamp).getTime() :
+                undefined);
+        return {
+            success: true,
+            data: {
+                traceId,
+                status,
+                command,
+                commandType,
+                startTime: startEvent?.timestamp ?? events[0]?.timestamp,
+                endTime: endEvent?.timestamp,
+                durationMs,
+                // Execution context
+                provider,
+                model,
+                // Input/Output
+                input,
+                output,
+                // Workflow steps (for agent runs)
+                workflowSteps: workflowSteps.length > 0 ? workflowSteps : undefined,
+                // Summary
+                summary: {
+                    eventCount: events.length,
+                    stepCount: stepEvents.length,
+                    errorCount: errorEvents.length,
+                },
+                // Full timeline for advanced view
+                timeline,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to fetch trace',
+        };
+    }
+}
+/**
+ * Get workflow definition
+ */
+async function handleWorkflowDetail(workflowId) {
+    try {
+        const loader = await getWorkflowLoader();
+        const workflow = await loader.load(workflowId);
+        if (!workflow) {
+            return { success: false, error: `Workflow not found: ${workflowId}` };
+        }
+        // Build DAG structure for visualization
+        const nodes = workflow.steps.map((step, index) => ({
+            id: step.stepId,
+            type: step.type,
+            name: step.name ?? step.stepId,
+            config: step.config,
+            position: index,
+        }));
+        // Build edges based on step order (sequential by default)
+        const edges = [];
+        for (let i = 0; i < workflow.steps.length - 1; i++) {
+            const currentStep = workflow.steps[i];
+            const nextStep = workflow.steps[i + 1];
+            if (currentStep && nextStep) {
+                edges.push({
+                    from: currentStep.stepId,
+                    to: nextStep.stepId,
+                });
+            }
+        }
+        return {
+            success: true,
+            data: {
+                workflowId: workflow.workflowId,
+                version: workflow.version,
+                name: workflow.name,
+                description: workflow.description,
+                steps: workflow.steps,
+                dag: { nodes, edges },
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to fetch workflow',
+        };
+    }
+}
+/**
+ * Get provider history - all trace events associated with a provider
+ * Uses context.providerId for filtering (INV-TR-010)
+ */
+async function handleProviderHistory(providerId) {
+    try {
+        const traceStore = getTraceStore();
+        const traces = await traceStore.listTraces(100);
+        const providerTraces = [];
+        // Filter traces by providerId
+        for (const trace of traces) {
+            const events = await traceStore.getTrace(trace.traceId);
+            const startEvent = events.find(e => e.type === 'run.start');
+            const endEvent = events.find(e => e.type === 'run.end');
+            // Check if any event in this trace has the matching providerId
+            const hasProvider = events.some(e => {
+                const ctx = e.context;
+                return ctx?.providerId === providerId || ctx?.provider === providerId;
+            });
+            if (hasProvider) {
+                const startPayload = startEvent?.payload;
+                const endPayload = endEvent?.payload;
+                const context = startEvent?.context;
+                const traceEntry = {
+                    traceId: trace.traceId,
+                    command: startPayload?.command ?? 'unknown',
+                    status: trace.status,
+                    startTime: trace.startTime,
+                };
+                if (trace.durationMs !== undefined)
+                    traceEntry.durationMs = trace.durationMs;
+                if (context?.model)
+                    traceEntry.model = context.model;
+                const prompt = startPayload?.prompt ?? '';
+                if (prompt)
+                    traceEntry.promptPreview = prompt.slice(0, 100);
+                const response = endPayload?.response ?? '';
+                if (response)
+                    traceEntry.responsePreview = response.slice(0, 100);
+                if (context?.tokenUsage)
+                    traceEntry.tokenUsage = context.tokenUsage;
+                providerTraces.push(traceEntry);
+            }
+        }
+        // Get provider info
+        const registry = getProviderRegistry();
+        const provider = registry.get(providerId);
+        return {
+            success: true,
+            data: {
+                providerId,
+                providerName: providerId,
+                available: provider ? await provider.isAvailable() : false,
+                totalRequests: providerTraces.length,
+                successRate: providerTraces.length > 0
+                    ? providerTraces.filter(t => t.status === 'success').length / providerTraces.length
+                    : 1.0,
+                avgLatencyMs: providerTraces.length > 0
+                    ? providerTraces.reduce((sum, t) => sum + (t.durationMs ?? 0), 0) / providerTraces.length
+                    : 0,
+                requests: providerTraces,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to fetch provider history',
+        };
+    }
+}
+/**
+ * Get agent history - all trace events associated with an agent
+ * Uses context.agentId for filtering (INV-TR-011)
+ */
+async function handleAgentHistory(agentId) {
+    try {
+        const traceStore = getTraceStore();
+        const traces = await traceStore.listTraces(100);
+        const agentTraces = [];
+        // Filter traces by agentId
+        for (const trace of traces) {
+            const events = await traceStore.getTrace(trace.traceId);
+            const startEvent = events.find(e => e.type === 'run.start');
+            const endEvent = events.find(e => e.type === 'run.end');
+            // Check if any event in this trace has the matching agentId
+            const hasAgent = events.some(e => {
+                const ctx = e.context;
+                return ctx?.agentId === agentId;
+            });
+            if (hasAgent) {
+                const startPayload = startEvent?.payload;
+                const endPayload = endEvent?.payload;
+                const traceEntry = {
+                    traceId: trace.traceId,
+                    status: trace.status,
+                    startTime: trace.startTime,
+                };
+                if (startPayload?.task)
+                    traceEntry.task = startPayload.task;
+                if (trace.durationMs !== undefined)
+                    traceEntry.durationMs = trace.durationMs;
+                if (endPayload?.stepCount !== undefined)
+                    traceEntry.stepCount = endPayload.stepCount;
+                if (endPayload?.successfulSteps !== undefined)
+                    traceEntry.successfulSteps = endPayload.successfulSteps;
+                const resultStr = endPayload?.result ?? '';
+                if (resultStr)
+                    traceEntry.result = resultStr.slice(0, 200);
+                if (endPayload?.error)
+                    traceEntry.error = endPayload.error;
+                agentTraces.push(traceEntry);
+            }
+        }
+        // Get agent info
+        const registry = await getAgentRegistry();
+        const agent = await registry.get(agentId);
+        return {
+            success: true,
+            data: {
+                agentId,
+                displayName: agent?.displayName ?? agentId,
+                description: agent?.description,
+                enabled: agent?.enabled ?? false,
+                capabilities: agent?.capabilities ?? [],
+                totalExecutions: agentTraces.length,
+                successRate: agentTraces.length > 0
+                    ? agentTraces.filter(t => t.status === 'success').length / agentTraces.length
+                    : 1.0,
+                avgDurationMs: agentTraces.length > 0
+                    ? agentTraces.reduce((sum, t) => sum + (t.durationMs ?? 0), 0) / agentTraces.length
+                    : 0,
+                executions: agentTraces,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to fetch agent history',
+        };
+    }
+}
+/**
+ * Search traces with filters
+ */
+async function handleTraceSearch(filters) {
+    try {
+        const traceStore = getTraceStore();
+        const traces = await traceStore.listTraces(filters.limit ?? 100);
+        const filteredTraces = [];
+        for (const trace of traces) {
+            const events = await traceStore.getTrace(trace.traceId);
+            const startEvent = events.find(e => e.type === 'run.start' || e.type === 'discussion.start' || e.type === 'workflow.start');
+            // Extract context from first event
+            const context = startEvent?.context;
+            const payload = startEvent?.payload;
+            const eventProviderId = context?.providerId;
+            const eventAgentId = context?.agentId;
+            const eventType = startEvent?.type;
+            // Apply filters
+            if (filters.providerId && eventProviderId !== filters.providerId)
+                continue;
+            if (filters.agentId && eventAgentId !== filters.agentId)
+                continue;
+            if (filters.type && eventType !== filters.type)
+                continue;
+            const traceEntry = {
+                traceId: trace.traceId,
+                status: trace.status,
+                startTime: trace.startTime,
+            };
+            if (payload?.command)
+                traceEntry.command = payload.command;
+            if (trace.durationMs !== undefined)
+                traceEntry.durationMs = trace.durationMs;
+            if (eventProviderId)
+                traceEntry.providerId = eventProviderId;
+            if (eventAgentId)
+                traceEntry.agentId = eventAgentId;
+            if (eventType)
+                traceEntry.eventType = eventType;
+            filteredTraces.push(traceEntry);
+        }
+        return {
+            success: true,
+            data: {
+                count: filteredTraces.length,
+                filters,
+                traces: filteredTraces,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to search traces',
+        };
+    }
+}
+/**
+ * Get trace tree - hierarchical view of trace and its children
+ * INV-TR-020: All traces in hierarchy share rootTraceId
+ * INV-TR-021: Shows parent-child relationships
+ */
+async function handleTraceTree(traceId) {
+    try {
+        const traceStore = getTraceStore();
+        const tree = await traceStore.getTraceTree(traceId);
+        if (!tree) {
+            return { success: false, error: `Trace not found: ${traceId}` };
+        }
+        const formatNode = (node) => ({
+            traceId: node.trace.traceId,
+            shortId: node.trace.traceId.slice(0, 8),
+            status: node.trace.status,
+            agentId: node.trace.agentId,
+            durationMs: node.trace.durationMs,
+            depth: node.trace.traceDepth ?? 0,
+            eventCount: node.trace.eventCount,
+            startTime: node.trace.startTime,
+            children: (node.children).map(formatNode),
+        });
+        // Count total nodes
+        const countNodes = (node) => 1 + (node.children).reduce((sum, child) => sum + countNodes(child), 0);
+        // Get max depth
+        const getMaxDepth = (node) => {
+            const childDepths = (node.children).map(getMaxDepth);
+            return childDepths.length > 0 ? Math.max(...childDepths) + 1 : 0;
+        };
+        const totalTraces = countNodes(tree);
+        const maxDepth = getMaxDepth(tree);
+        // Build text tree view for display
+        const buildTreeView = (node, indent = '') => {
+            const statusIcon = node.trace.status === 'success' ? '[OK]' :
+                node.trace.status === 'failure' ? '[FAIL]' :
+                    node.trace.status === 'running' ? '[...]' : '[?]';
+            const agentLabel = node.trace.agentId ? ` - ${node.trace.agentId}` : '';
+            const durationLabel = node.trace.durationMs ? ` (${node.trace.durationMs}ms)` : '';
+            const line = `${indent}${statusIcon} ${node.trace.traceId.slice(0, 8)}${agentLabel}${durationLabel}`;
+            const lines = [line];
+            const children = node.children;
+            for (let i = 0; i < children.length; i++) {
+                const isLast = i === children.length - 1;
+                const childIndent = indent + (isLast ? ' └─ ' : ' ├─ ');
+                const nextIndent = indent + (isLast ? '    ' : ' │  ');
+                const childLines = buildTreeView(children[i], nextIndent);
+                childLines[0] = childIndent.slice(0, -4) + (isLast ? ' └─ ' : ' ├─ ') + childLines[0].slice(nextIndent.length);
+                lines.push(...childLines);
+            }
+            return lines;
+        };
+        const treeView = buildTreeView(tree).join('\n');
+        return {
+            success: true,
+            data: {
+                traceId,
+                rootTraceId: tree.trace.rootTraceId ?? traceId,
+                traceCount: totalTraces,
+                maxDepth,
+                totalDurationMs: tree.totalDurationMs,
+                totalEventCount: tree.totalEventCount,
+                treeView,
+                tree: formatNode(tree),
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to get trace tree',
+        };
+    }
+}
+/**
+ * Get workflow execution events - timeline of a workflow execution
+ * Uses workflow.start, workflow.step, workflow.end events (INV-TR-013)
+ */
+async function handleWorkflowEvents(workflowId) {
+    try {
+        const traceStore = getTraceStore();
+        const traces = await traceStore.listTraces(100);
+        const workflowExecutions = [];
+        // Find traces with workflow events for this workflowId
+        for (const trace of traces) {
+            const events = await traceStore.getTrace(trace.traceId);
+            // Look for workflow events
+            const workflowStart = events.find(e => e.type === 'workflow.start');
+            const workflowEnd = events.find(e => e.type === 'workflow.end');
+            const workflowSteps = events.filter(e => e.type === 'workflow.step');
+            // Check if this is the right workflow
+            const startContext = workflowStart?.context;
+            const endContext = workflowEnd?.context;
+            if (startContext?.workflowId === workflowId || endContext?.workflowId === workflowId) {
+                const startPayload = workflowStart?.payload;
+                const endPayload = workflowEnd?.payload;
+                // Build timeline
+                const timeline = [];
+                // Add start event
+                if (workflowStart) {
+                    timeline.push({
+                        type: 'workflow.start',
+                        timestamp: workflowStart.timestamp,
+                    });
+                }
+                // Add step events
+                for (const step of workflowSteps) {
+                    const stepPayload = step.payload;
+                    const stepEntry = {
+                        type: 'workflow.step',
+                        timestamp: step.timestamp,
+                    };
+                    if (stepPayload?.stepId)
+                        stepEntry.stepId = stepPayload.stepId;
+                    if (stepPayload?.stepName)
+                        stepEntry.stepName = stepPayload.stepName;
+                    if (stepPayload?.success !== undefined)
+                        stepEntry.success = stepPayload.success;
+                    if (step.durationMs !== undefined)
+                        stepEntry.durationMs = step.durationMs;
+                    if (stepPayload?.error)
+                        stepEntry.error = stepPayload.error;
+                    timeline.push(stepEntry);
+                }
+                // Add end event
+                if (workflowEnd) {
+                    const endEntry = {
+                        type: 'workflow.end',
+                        timestamp: workflowEnd.timestamp,
+                    };
+                    if (endPayload?.success !== undefined)
+                        endEntry.success = endPayload.success;
+                    if (workflowEnd.durationMs !== undefined)
+                        endEntry.durationMs = workflowEnd.durationMs;
+                    if (endPayload?.error)
+                        endEntry.error = endPayload.error;
+                    timeline.push(endEntry);
+                }
+                const executionEntry = {
+                    traceId: trace.traceId,
+                    status: endPayload?.success === true ? 'success' : (workflowEnd ? 'failure' : 'running'),
+                    startTime: workflowStart?.timestamp ?? trace.startTime,
+                    totalSteps: startPayload?.stepCount ?? endPayload?.totalSteps ?? workflowSteps.length,
+                    completedSteps: endPayload?.completedSteps ?? workflowSteps.length,
+                    failedSteps: endPayload?.failedSteps ?? workflowSteps.filter(s => {
+                        const p = s.payload;
+                        return p?.success === false;
+                    }).length,
+                    timeline,
+                };
+                if (workflowEnd?.timestamp)
+                    executionEntry.endTime = workflowEnd.timestamp;
+                const durationMs = endPayload?.totalDurationMs ?? trace.durationMs;
+                if (durationMs !== undefined)
+                    executionEntry.durationMs = durationMs;
+                workflowExecutions.push(executionEntry);
+            }
+        }
+        // Get workflow definition
+        const loader = await getWorkflowLoader();
+        const workflow = await loader.load(workflowId);
+        return {
+            success: true,
+            data: {
+                workflowId,
+                workflowName: workflow?.name,
+                workflowVersion: workflow?.version,
+                stepCount: workflow?.steps.length ?? 0,
+                totalExecutions: workflowExecutions.length,
+                successRate: workflowExecutions.length > 0
+                    ? workflowExecutions.filter(e => e.status === 'success').length / workflowExecutions.length
+                    : 1.0,
+                executions: workflowExecutions,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to fetch workflow events',
+        };
+    }
+}
+/**
+ * Fetch provider data
+ */
+async function getProviderData() {
+    try {
+        const registry = getProviderRegistry();
+        const providerIds = registry.getProviderIds();
+        const results = await Promise.all(providerIds.map(async (providerId) => {
+            const provider = registry.get(providerId);
+            if (!provider)
+                return null;
+            const startTime = Date.now();
+            try {
+                const available = await provider.isAvailable();
+                const latencyMs = Date.now() - startTime;
+                return {
+                    providerId,
+                    name: providerId,
+                    available,
+                    latencyMs: available ? latencyMs : undefined,
+                    circuitState: 'closed',
+                    lastUsed: undefined,
+                };
+            }
+            catch {
+                return {
+                    providerId,
+                    name: providerId,
+                    available: false,
+                    latencyMs: undefined,
+                    circuitState: 'closed',
+                    lastUsed: undefined,
+                };
+            }
+        }));
+        return results.filter((r) => r !== null);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Fetch session data
+ */
+async function getSessionData() {
+    try {
+        const manager = getSessionManager();
+        const sessions = await manager.listSessions({ status: 'active' });
+        return sessions.slice(0, 20).map(session => ({
+            sessionId: session.sessionId,
+            initiator: session.initiator,
+            task: session.task,
+            status: session.status,
+            participantCount: session.participants.filter(p => !p.leftAt).length,
+            createdAt: session.createdAt,
+            durationMs: undefined,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Fetch agent data
+ */
+async function getAgentData() {
+    try {
+        const registry = await getAgentRegistry();
+        const agents = await registry.list();
+        return agents.slice(0, 50).map(agent => ({
+            agentId: agent.agentId,
+            displayName: agent.displayName ?? agent.agentId,
+            description: agent.description,
+            enabled: agent.enabled ?? true,
+            capabilities: agent.capabilities ?? [],
+            executionCount: 0,
+            lastExecuted: undefined,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Fetch trace data with command info from events
+ */
+async function getTraceData() {
+    try {
+        const traceStore = getTraceStore();
+        const traces = await traceStore.listTraces(200); // Increased for histogram
+        // Fetch first event of each trace to get command info
+        const tracesWithNames = await Promise.all(traces.map(async (trace) => {
+            let name = `Trace ${trace.traceId.slice(0, 8)}`;
+            let command;
+            let providers;
+            try {
+                const events = await traceStore.getTrace(trace.traceId);
+                const firstEvent = events[0];
+                if (firstEvent) {
+                    const payload = firstEvent.payload;
+                    const context = firstEvent.context;
+                    // Extract command from payload
+                    if (payload?.command) {
+                        command = String(payload.command);
+                        name = command;
+                    }
+                    // Extract providers from payload (for discussions) or context (for single calls)
+                    if (payload?.providers && Array.isArray(payload.providers)) {
+                        providers = payload.providers;
+                    }
+                    else if (context?.providerId) {
+                        providers = [String(context.providerId)];
+                    }
+                    // Add additional context for different command types
+                    if (payload?.agentId) {
+                        name = `ax agent run ${payload.agentId}`;
+                    }
+                    else if (payload?.topic) {
+                        const topic = String(payload.topic).slice(0, 40);
+                        name = `ax discuss "${topic}${String(payload.topic).length > 40 ? '...' : ''}"`;
+                    }
+                    else if (payload?.prompt) {
+                        const prompt = String(payload.prompt).slice(0, 40);
+                        name = `${command ?? 'ax call'} "${prompt}${String(payload.prompt).length > 40 ? '...' : ''}"`;
+                    }
+                }
+            }
+            catch {
+                // Ignore errors fetching events
+            }
+            return {
+                traceId: trace.traceId,
+                name,
+                command,
+                status: trace.status === 'pending' || trace.status === 'skipped' ? 'running' : trace.status,
+                eventCount: trace.eventCount,
+                durationMs: trace.durationMs,
+                startTime: trace.startTime,
+                providers,
+            };
+        }));
+        return tracesWithNames;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Fetch workflow data
+ */
+async function getWorkflowData() {
+    try {
+        const loader = await getWorkflowLoader();
+        const workflows = await loader.loadAll();
+        return workflows.slice(0, 50).map(workflow => ({
+            workflowId: workflow.workflowId,
+            name: workflow.name ?? workflow.workflowId,
+            version: workflow.version,
+            stepCount: workflow.steps.length,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Fetch metrics data
+ */
+async function getMetricsData() {
+    const memUsage = process.memoryUsage();
+    let activeSessions = 0;
+    let activeAgents = 0;
+    try {
+        const manager = getSessionManager();
+        activeSessions = await manager.countActiveSessions();
+    }
+    catch {
+        // ignore
+    }
+    try {
+        const registry = await getAgentRegistry();
+        const agents = await registry.list();
+        activeAgents = agents.filter(a => a.enabled !== false).length;
+    }
+    catch {
+        // ignore
+    }
+    return {
+        totalRequests: 0, // Would need request tracking
+        successRate: 1.0,
+        avgLatencyMs: 0,
+        activeAgents,
+        activeSessions,
+        memoryUsageMb: memUsage.heapUsed / (1024 * 1024),
+        heapTotalMb: memUsage.heapTotal / (1024 * 1024),
+        rssMb: memUsage.rss / (1024 * 1024),
+        uptime: formatUptime(process.uptime()),
+        uptimeSeconds: process.uptime(),
+    };
+}
+/**
+ * Format uptime
+ */
+function formatUptime(seconds) {
+    const days = Math.floor(seconds / 86400);
+    const hours = Math.floor((seconds % 86400) / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const secs = Math.floor(seconds % 60);
+    const parts = [];
+    if (days > 0)
+        parts.push(`${days}d`);
+    if (hours > 0)
+        parts.push(`${hours}h`);
+    if (minutes > 0)
+        parts.push(`${minutes}m`);
+    if (secs > 0 || parts.length === 0)
+        parts.push(`${secs}s`);
+    return parts.join(' ');
+}
+//# sourceMappingURL=api.js.map