@bluefly/openstandardagents 0.5.1 → 0.5.3

package/dist/services/observability/observability-generator.service.js

@@ -1,1419 +0,0 @@
-/**
- * Observability Generator Service
- *
- * Generates deployable observability configuration from an OSSA agent manifest:
- *   - observability/traces.yaml     OTel Collector pipeline config
- *   - observability/metrics.yaml    Prometheus-compatible metric definitions
- *   - observability/dashboards/agent-health.json   Grafana dashboard template
- *
- * Uses OpenTelemetry gen_ai semantic conventions (v1.39.0 experimental).
- * Reference: src/adapters/opentelemetry.adapter.ts for runtime patterns.
- * This service generates static config FILES, not runtime initialization.
- *
- * SOLID: Single Responsibility - observability config generation only
- * DRY: Reuses OssaAgent types, single-source manifest
- */
-import * as yaml from 'yaml';
-// ── Service ─────────────────────────────────────────────────────────
-export class ObservabilityGeneratorService {
-    /**
-     * Generate observability configuration files from an OSSA manifest.
-     *
-     * @param manifest - A validated OssaAgent manifest
-     * @returns ExportFile[] ready for disk write or archive
-     */
-    generate(manifest) {
-        const identity = this.resolveIdentity(manifest);
-        const endpoints = this.resolveEndpoints(manifest);
-        const constraints = this.resolveConstraints(manifest);
-        const tools = this.resolveTools(manifest);
-        const team = this.resolveTeam(manifest);
-        const isMultiAgent = team.length > 0;
-        const files = [
-            this.generateTracesYaml(identity, endpoints, tools, team),
-            this.generateMetricsYaml(identity, endpoints, constraints, tools, team),
-            this.generateDashboardJson(identity, constraints, tools, isMultiAgent),
-        ];
-        return files;
-    }
-    // ── Identity resolution ─────────────────────────────────────────
-    resolveIdentity(manifest) {
-        const meta = manifest.metadata;
-        const spec = manifest.spec;
-        return {
-            name: meta?.name ?? 'unnamed-agent',
-            version: meta?.version ?? '0.0.0',
-            provider: spec?.llm?.provider ?? 'unknown',
-            model: spec?.llm?.model ?? 'unknown',
-            pattern: meta?.agentArchitecture?.pattern ?? 'single',
-            agentType: meta?.agentType ?? 'custom',
-            agentKind: meta?.agentKind ?? 'worker',
-        };
-    }
-    // ── Endpoint resolution ─────────────────────────────────────────
-    resolveEndpoints(manifest) {
-        const obs = manifest.spec?.observability;
-        const ext = manifest.extensions?.observability;
-        const extTraces = ext?.traces;
-        const extMetrics = ext?.metrics;
-        // Prefer spec.observability, fall back to extensions.observability, then defaults
-        const tracesEndpoint = obs?.tracing?.endpoint ??
-            extTraces?.endpoint ??
-            'http://localhost:4318/v1/traces';
-        const metricsEndpoint = obs?.metrics?.endpoint ??
-            extMetrics?.endpoint ??
-            'http://localhost:4318/v1/metrics';
-        const tracesExporter = obs?.tracing?.exporter ?? 'otlp';
-        const metricsExporter = obs?.metrics?.exporter ?? 'otlp';
-        const sampleRate = extTraces?.sample_rate ?? 1.0;
-        const collectionIntervalSeconds = extMetrics?.collection_interval_seconds ?? 60;
-        return {
-            tracesEndpoint,
-            metricsEndpoint,
-            tracesExporter,
-            metricsExporter,
-            sampleRate,
-            collectionIntervalSeconds,
-        };
-    }
-    // ── Constraint resolution ───────────────────────────────────────
-    resolveConstraints(manifest) {
-        const cost = manifest.spec?.constraints?.cost;
-        const perf = manifest.spec?.constraints?.performance;
-        return {
-            maxTokensPerDay: cost?.maxTokensPerDay ?? 1_000_000,
-            maxCostPerDay: cost?.maxCostPerDay ?? 100,
-            maxLatencySeconds: perf?.maxLatencySeconds ?? 30,
-            maxErrorRate: perf?.maxErrorRate ?? 0.05,
-            timeoutSeconds: perf?.timeoutSeconds ?? 120,
-        };
-    }
-    // ── Tool resolution ─────────────────────────────────────────────
-    resolveTools(manifest) {
-        const tools = manifest.spec?.tools ?? [];
-        return tools.map((t) => t.name ?? t.type ?? 'unknown_tool');
-    }
-    // ── Team resolution ─────────────────────────────────────────────
-    resolveTeam(manifest) {
-        const spec = manifest.spec;
-        if (!spec)
-            return [];
-        // Check spec.team.members (primary path for multi-agent)
-        const team = spec.team;
-        if (team?.members && Array.isArray(team.members)) {
-            return team.members.map((m) => ({
-                name: m.name ?? 'unnamed',
-                role: m.role ?? 'worker',
-            }));
-        }
-        // Check spec.swarm.agents
-        const swarm = spec.swarm;
-        if (swarm?.agents && Array.isArray(swarm.agents)) {
-            return swarm.agents.map((a) => ({
-                name: a.name ?? 'unnamed',
-                role: a.role ?? 'worker',
-            }));
-        }
-        // Check spec.subagents
-        if (spec.subagents && Array.isArray(spec.subagents)) {
-            return spec.subagents.map((s) => ({
-                name: s.name ?? 'unnamed',
-                role: s.role ?? 'worker',
-            }));
-        }
-        return [];
-    }
-    // ── Traces YAML ─────────────────────────────────────────────────
-    generateTracesYaml(identity, endpoints, tools, team) {
-        const isMultiAgent = team.length > 0;
-        // Build OTel Collector config using gen_ai semantic conventions
-        const config = {
-            // Header comment captured as YAML comment below
-            receivers: {
-                otlp: {
-                    protocols: {
-                        http: {
-                            endpoint: '0.0.0.0:4318',
-                        },
-                        grpc: {
-                            endpoint: '0.0.0.0:4317',
-                        },
-                    },
-                },
-            },
-            processors: {
-                batch: {
-                    timeout: '5s',
-                    send_batch_size: 512,
-                    send_batch_max_size: 1024,
-                },
-                // Enrich all spans with agent resource attributes
-                resource: {
-                    attributes: [
-                        { key: 'service.name', value: identity.name, action: 'upsert' },
-                        {
-                            key: 'service.version',
-                            value: identity.version,
-                            action: 'upsert',
-                        },
-                        {
-                            key: 'gen_ai.agent.name',
-                            value: identity.name,
-                            action: 'upsert',
-                        },
-                        {
-                            key: 'gen_ai.provider.name',
-                            value: identity.provider,
-                            action: 'upsert',
-                        },
-                        {
-                            key: 'gen_ai.request.model',
-                            value: identity.model,
-                            action: 'upsert',
-                        },
-                        {
-                            key: 'ossa.agent.type',
-                            value: identity.agentType,
-                            action: 'upsert',
-                        },
-                        {
-                            key: 'ossa.agent.kind',
-                            value: identity.agentKind,
-                            action: 'upsert',
-                        },
-                        {
-                            key: 'ossa.agent.architecture.pattern',
-                            value: identity.pattern,
-                            action: 'upsert',
-                        },
-                    ],
-                },
-                // Probabilistic sampling for high-throughput agents
-                probabilistic_sampler: {
-                    sampling_percentage: endpoints.sampleRate * 100,
-                },
-                // Span filtering: keep only gen_ai.* and agent.* spans in production
-                filter: {
-                    error_mode: 'ignore',
-                    traces: {
-                        span: [
-                            'attributes["gen_ai.operation.name"] != nil',
-                            'attributes["gen_ai.agent.name"] != nil',
-                            'name == "invoke_agent"',
-                            'name == "gen_ai.tool.call"',
-                            'name == "gen_ai.chat"',
-                            'name == "gen_ai.content.completion"',
-                        ],
-                    },
-                },
-            },
-            exporters: this.buildTraceExporters(endpoints),
-            service: {
-                pipelines: {
-                    traces: {
-                        receivers: ['otlp'],
-                        processors: ['resource', 'probabilistic_sampler', 'batch'],
-                        exporters: this.buildTraceExporterNames(endpoints),
-                    },
-                },
-                telemetry: {
-                    logs: {
-                        level: 'info',
-                    },
-                },
-            },
-        };
-        // Add span definitions as documentation for instrumentation
-        const spanDefinitions = this.buildSpanDefinitions(identity, tools, team, isMultiAgent);
-        const yamlContent = [
-            `# OpenTelemetry Collector configuration for ${identity.name}`,
-            `# Generated from OSSA manifest v${identity.version}`,
-            `# gen_ai semantic conventions v1.39.0 (experimental)`,
-            '#',
-            '# Span naming conventions:',
-            '#   invoke_agent           - Top-level agent invocation (kind: CLIENT)',
-            '#   gen_ai.chat            - LLM chat completion call (kind: CLIENT)',
-            '#   gen_ai.content.completion - Content generation (kind: INTERNAL)',
-            '#   gen_ai.tool.call       - Tool invocation (kind: INTERNAL)',
-            ...(isMultiAgent
-                ? [
-                    '#   agent.handoff          - Inter-agent handoff (kind: INTERNAL)',
-                    '#   agent.coordinate       - Team coordination (kind: INTERNAL)',
-                ]
-                : []),
-            '#',
-            yaml.stringify(config, { lineWidth: 120 }),
-            '',
-            '# ── Span Definitions (for instrumentation reference) ──',
-            '#',
-            yaml.stringify({ _span_definitions: spanDefinitions }, { lineWidth: 120 }),
-        ].join('\n');
-        return {
-            path: 'observability/traces.yaml',
-            content: yamlContent,
-            type: 'config',
-            language: 'yaml',
-        };
-    }
-    buildTraceExporters(endpoints) {
-        const exporters = {};
-        switch (endpoints.tracesExporter) {
-            case 'jaeger':
-                exporters.jaeger = {
-                    endpoint: endpoints.tracesEndpoint,
-                    tls: { insecure: true },
-                };
-                break;
-            case 'zipkin':
-                exporters.zipkin = {
-                    endpoint: endpoints.tracesEndpoint,
-                };
-                break;
-            case 'otlp':
-            default:
-                exporters.otlp = {
-                    endpoint: endpoints.tracesEndpoint,
-                    tls: { insecure: true },
-                };
-                break;
-        }
-        // Always include debug exporter for development
-        exporters.debug = {
-            verbosity: 'basic',
-        };
-        return exporters;
-    }
-    buildTraceExporterNames(endpoints) {
-        const names = [];
-        switch (endpoints.tracesExporter) {
-            case 'jaeger':
-                names.push('jaeger');
-                break;
-            case 'zipkin':
-                names.push('zipkin');
-                break;
-            case 'otlp':
-            default:
-                names.push('otlp');
-                break;
-        }
-        names.push('debug');
-        return names;
-    }
-    buildSpanDefinitions(identity, tools, team, isMultiAgent) {
-        const spans = [
-            {
-                name: 'invoke_agent',
-                kind: 'CLIENT',
-                description: `Top-level invocation of ${identity.name}`,
-                attributes: {
-                    'gen_ai.agent.name': identity.name,
-                    'gen_ai.operation.name': 'invoke_agent',
-                    'gen_ai.request.model': identity.model,
-                    'gen_ai.provider.name': identity.provider,
-                    'gen_ai.agent.description': `${identity.agentKind} agent (${identity.pattern} pattern)`,
-                },
-            },
-            {
-                name: 'gen_ai.chat',
-                kind: 'CLIENT',
-                description: 'LLM chat completion request',
-                attributes: {
-                    'gen_ai.operation.name': 'chat',
-                    'gen_ai.request.model': identity.model,
-                    'gen_ai.provider.name': identity.provider,
-                    'gen_ai.request.temperature': '${temperature}',
-                    'gen_ai.request.max_tokens': '${maxTokens}',
-                    'gen_ai.request.top_p': '${topP}',
-                },
-                events: [
-                    {
-                        name: 'gen_ai.content.prompt',
-                        attributes: { 'gen_ai.prompt': '${prompt_content}' },
-                    },
-                    {
-                        name: 'gen_ai.content.completion',
-                        attributes: { 'gen_ai.completion': '${completion_content}' },
-                    },
-                ],
-                metrics_on_end: {
-                    'gen_ai.usage.input_tokens': '${input_tokens}',
-                    'gen_ai.usage.output_tokens': '${output_tokens}',
-                },
-            },
-        ];
-        // Tool call spans
-        for (const toolName of tools) {
-            spans.push({
-                name: 'gen_ai.tool.call',
-                kind: 'INTERNAL',
-                description: `Tool invocation: ${toolName}`,
-                attributes: {
-                    'gen_ai.operation.name': 'tool_call',
-                    'gen_ai.tool.name': toolName,
-                    'gen_ai.tool.call.id': '${call_id}',
-                    'gen_ai.tool.parameters': '${parameters_json}',
-                },
-            });
-        }
-        // Multi-agent coordination spans
-        if (isMultiAgent) {
-            spans.push({
-                name: 'agent.handoff',
-                kind: 'INTERNAL',
-                description: 'Handoff between agents in the team',
-                attributes: {
-                    'gen_ai.operation.name': 'handoff',
-                    'ossa.handoff.source_agent': '${source_agent}',
-                    'ossa.handoff.target_agent': '${target_agent}',
-                    'ossa.handoff.reason': '${reason}',
-                },
-            }, {
-                name: 'agent.coordinate',
-                kind: 'INTERNAL',
-                description: 'Team coordination event',
-                attributes: {
-                    'gen_ai.operation.name': 'coordinate',
-                    'ossa.coordination.team_size': String(team.length),
-                    'ossa.coordination.pattern': identity.pattern,
-                    'ossa.coordination.leader': '${leader_name}',
-                },
-            });
-            // Per-member invocation spans
-            for (const member of team) {
-                spans.push({
-                    name: `invoke_agent`,
-                    kind: 'INTERNAL',
-                    description: `Invocation of team member: ${member.name} (${member.role})`,
-                    attributes: {
-                        'gen_ai.agent.name': member.name,
-                        'gen_ai.operation.name': 'invoke_agent',
-                        'ossa.agent.role': member.role,
-                        'ossa.team.parent': identity.name,
-                    },
-                });
-            }
-        }
-        return spans;
-    }
-    // ── Metrics YAML ────────────────────────────────────────────────
-    generateMetricsYaml(identity, endpoints, constraints, tools, team) {
-        const isMultiAgent = team.length > 0;
-        const sanitizedName = identity.name.replace(/[^a-zA-Z0-9_]/g, '_');
-        const metricDefinitions = this.buildMetricDefinitions(sanitizedName, identity, constraints, tools, team, isMultiAgent);
-        // OTel Collector config fragment for metrics pipeline
-        const collectorConfig = {
-            receivers: {
-                otlp: {
-                    protocols: {
-                        http: { endpoint: '0.0.0.0:4318' },
-                        grpc: { endpoint: '0.0.0.0:4317' },
-                    },
-                },
-                prometheus: {
-                    config: {
-                        scrape_configs: [
-                            {
-                                job_name: `${identity.name}-metrics`,
-                                scrape_interval: `${endpoints.collectionIntervalSeconds}s`,
-                                static_configs: [
-                                    {
-                                        targets: ['localhost:9464'],
-                                        labels: {
-                                            agent: identity.name,
-                                            version: identity.version,
-                                            provider: identity.provider,
-                                        },
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                },
-            },
-            processors: {
-                batch: {
-                    timeout: '10s',
-                    send_batch_size: 256,
-                },
-                resource: {
-                    attributes: [
-                        { key: 'service.name', value: identity.name, action: 'upsert' },
-                        {
-                            key: 'service.version',
-                            value: identity.version,
-                            action: 'upsert',
-                        },
-                    ],
-                },
-            },
-            exporters: this.buildMetricExporters(endpoints),
-            service: {
-                pipelines: {
-                    metrics: {
-                        receivers: ['otlp', 'prometheus'],
-                        processors: ['resource', 'batch'],
-                        exporters: this.buildMetricExporterNames(endpoints),
-                    },
-                },
-            },
-        };
-        // Prometheus recording rules for derived metrics
-        const recordingRules = this.buildRecordingRules(sanitizedName, identity, constraints, isMultiAgent);
-        // Alert rules based on constraints
-        const alertRules = this.buildAlertRules(sanitizedName, identity, constraints, isMultiAgent);
-        const yamlContent = [
-            `# Metrics configuration for ${identity.name}`,
-            `# Generated from OSSA manifest v${identity.version}`,
-            `# gen_ai semantic conventions v1.39.0 (experimental)`,
-            '#',
-            '# Includes:',
-            '#   - OTel Collector metrics pipeline config',
-            '#   - Metric definitions (Prometheus-compatible)',
-            '#   - Recording rules (pre-computed aggregates)',
-            '#   - Alert rules (constraint-based thresholds)',
-            '#',
-            '',
-            '# ── OTel Collector Config ──',
-            yaml.stringify(collectorConfig, { lineWidth: 120 }),
-            '',
-            '# ── Metric Definitions ──',
-            yaml.stringify({ metric_definitions: metricDefinitions }, { lineWidth: 120 }),
-            '',
-            '# ── Prometheus Recording Rules ──',
-            yaml.stringify({ groups: [recordingRules] }, { lineWidth: 120 }),
-            '',
-            '# ── Prometheus Alert Rules ──',
-            yaml.stringify({ groups: [alertRules] }, { lineWidth: 120 }),
-        ].join('\n');
-        return {
-            path: 'observability/metrics.yaml',
-            content: yamlContent,
-            type: 'config',
-            language: 'yaml',
-        };
-    }
-    buildMetricExporters(endpoints) {
-        const exporters = {};
-        switch (endpoints.metricsExporter) {
-            case 'prometheus':
-                exporters.prometheus = {
-                    endpoint: '0.0.0.0:9464',
-                    namespace: 'ossa',
-                    const_labels: {
-                        source: 'ossa-agent',
-                    },
-                };
-                break;
-            case 'otlp':
-            default:
-                exporters.otlp = {
-                    endpoint: endpoints.metricsEndpoint,
-                    tls: { insecure: true },
-                };
-                break;
-        }
-        exporters.debug = {
-            verbosity: 'basic',
-        };
-        return exporters;
-    }
-    buildMetricExporterNames(endpoints) {
-        const names = [];
-        switch (endpoints.metricsExporter) {
-            case 'prometheus':
-                names.push('prometheus');
-                break;
-            case 'otlp':
-            default:
-                names.push('otlp');
-                break;
-        }
-        names.push('debug');
-        return names;
-    }
-    buildMetricDefinitions(sanitizedName, identity, constraints, tools, team, isMultiAgent) {
-        const metrics = [
-            // ── Token Usage ───────────────────────────────────
-            {
-                name: 'gen_ai_usage_input_tokens_total',
-                type: 'counter',
-                unit: 'tokens',
-                description: 'Total input tokens consumed by LLM requests',
-                labels: [
-                    'gen_ai.provider.name',
-                    'gen_ai.request.model',
-                    'gen_ai.agent.name',
-                ],
-                semantic_convention: 'gen_ai.usage.input_tokens',
-            },
-            {
-                name: 'gen_ai_usage_output_tokens_total',
-                type: 'counter',
-                unit: 'tokens',
-                description: 'Total output tokens generated by LLM responses',
-                labels: [
-                    'gen_ai.provider.name',
-                    'gen_ai.request.model',
-                    'gen_ai.agent.name',
-                ],
-                semantic_convention: 'gen_ai.usage.output_tokens',
-            },
-            {
-                name: `${sanitizedName}_tokens_daily_total`,
-                type: 'counter',
-                unit: 'tokens',
-                description: `Daily token budget consumption for ${identity.name}`,
-                labels: ['direction', 'gen_ai.request.model'],
-                threshold: constraints.maxTokensPerDay,
-            },
-            // ── Latency ───────────────────────────────────────
-            {
-                name: 'gen_ai_client_operation_duration_seconds',
-                type: 'histogram',
-                unit: 'seconds',
-                description: 'Duration of gen_ai operations (chat, tool_call, invoke_agent)',
-                labels: [
-                    'gen_ai.operation.name',
-                    'gen_ai.agent.name',
-                    'gen_ai.request.model',
-                ],
-                buckets: [0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0, 15.0, 30.0, 60.0, 120.0],
-                semantic_convention: 'gen_ai.client.operation.duration',
-                slo_threshold: constraints.maxLatencySeconds,
-            },
-            {
-                name: `${sanitizedName}_time_to_first_token_seconds`,
-                type: 'histogram',
-                unit: 'seconds',
-                description: 'Time to first token in streaming responses',
-                labels: ['gen_ai.request.model', 'gen_ai.provider.name'],
-                buckets: [0.05, 0.1, 0.2, 0.5, 1.0, 2.0, 5.0],
-            },
-            // ── Cost ──────────────────────────────────────────
-            {
-                name: `${sanitizedName}_cost_per_request_dollars`,
-                type: 'histogram',
-                unit: 'dollars',
-                description: 'Estimated cost per LLM request in USD',
-                labels: ['gen_ai.operation.name', 'gen_ai.request.model'],
-                buckets: [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1.0, 5.0],
-            },
-            {
-                name: `${sanitizedName}_cost_daily_total_dollars`,
-                type: 'counter',
-                unit: 'dollars',
-                description: `Daily cost accumulation for ${identity.name}`,
-                labels: ['gen_ai.request.model'],
-                threshold: constraints.maxCostPerDay,
-            },
-            // ── Error Tracking ────────────────────────────────
-            {
-                name: `${sanitizedName}_requests_total`,
-                type: 'counter',
-                description: 'Total requests processed by the agent',
-                labels: ['gen_ai.operation.name', 'status', 'error.type'],
-            },
-            {
-                name: `${sanitizedName}_errors_total`,
-                type: 'counter',
-                description: 'Total errors encountered by the agent',
-                labels: ['gen_ai.operation.name', 'error.type', 'gen_ai.request.model'],
-                threshold_rate: constraints.maxErrorRate,
-            },
-            // ── Tool Metrics ──────────────────────────────────
-            {
-                name: `${sanitizedName}_tool_calls_total`,
-                type: 'counter',
-                description: 'Total tool invocations',
-                labels: ['gen_ai.tool.name', 'status'],
-            },
-            {
-                name: `${sanitizedName}_tool_duration_seconds`,
-                type: 'histogram',
-                unit: 'seconds',
-                description: 'Duration of individual tool calls',
-                labels: ['gen_ai.tool.name'],
-                buckets: [0.01, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0, 30.0],
-            },
-            // ── Agent Lifecycle ───────────────────────────────
-            {
-                name: `${sanitizedName}_invocations_total`,
-                type: 'counter',
-                description: 'Total agent invocations',
-                labels: ['gen_ai.agent.name', 'status'],
-            },
-            {
-                name: `${sanitizedName}_active_invocations`,
-                type: 'gauge',
-                description: 'Currently active agent invocations',
-                labels: ['gen_ai.agent.name'],
-            },
-            {
-                name: `${sanitizedName}_invocation_duration_seconds`,
-                type: 'histogram',
-                unit: 'seconds',
-                description: 'End-to-end duration of a full agent invocation',
-                labels: ['gen_ai.agent.name', 'status'],
-                buckets: [0.5, 1.0, 2.5, 5.0, 10.0, 30.0, 60.0, 120.0, 300.0],
-            },
-        ];
-        // Per-tool specific counters
-        for (const tool of tools) {
-            metrics.push({
-                name: `${sanitizedName}_tool_${tool.replace(/[^a-zA-Z0-9_]/g, '_')}_calls_total`,
-                type: 'counter',
-                description: `Invocations of tool: ${tool}`,
-                labels: ['status', 'error.type'],
-            });
-        }
-        // ── Multi-agent / Team metrics ──────────────────────
-        if (isMultiAgent) {
-            metrics.push({
-                name: `${sanitizedName}_team_handoffs_total`,
-                type: 'counter',
-                description: 'Total handoffs between team members',
-                labels: ['source_agent', 'target_agent', 'reason'],
-            }, {
-                name: `${sanitizedName}_team_coordination_duration_seconds`,
-                type: 'histogram',
-                unit: 'seconds',
-                description: 'Duration of team coordination events',
-                labels: ['coordination_type', 'pattern'],
-                buckets: [0.1, 0.5, 1.0, 5.0, 10.0, 30.0, 60.0],
-            }, {
-                name: `${sanitizedName}_team_member_utilization_ratio`,
-                type: 'gauge',
-                description: 'Utilization ratio per team member (active time / total time)',
-                labels: ['gen_ai.agent.name', 'role'],
-            });
-            // Per-member metrics
-            for (const member of team) {
-                const memberSafe = member.name.replace(/[^a-zA-Z0-9_]/g, '_');
-                metrics.push({
-                    name: `${sanitizedName}_member_${memberSafe}_tokens_total`,
-                    type: 'counter',
-                    unit: 'tokens',
-                    description: `Token usage for team member: ${member.name} (${member.role})`,
-                    labels: ['direction', 'gen_ai.request.model'],
-                }, {
-                    name: `${sanitizedName}_member_${memberSafe}_invocations_total`,
-                    type: 'counter',
-                    description: `Invocations of team member: ${member.name}`,
-                    labels: ['status'],
-                });
-            }
-        }
-        return metrics;
-    }
-    buildRecordingRules(sanitizedName, identity, constraints, isMultiAgent) {
-        const rules = [
-            // Token usage rate (tokens per minute)
-            {
-                record: `${sanitizedName}:tokens_per_minute`,
-                expr: `rate(gen_ai_usage_input_tokens_total{gen_ai_agent_name="${identity.name}"}[5m]) + rate(gen_ai_usage_output_tokens_total{gen_ai_agent_name="${identity.name}"}[5m])`,
-            },
-            // Error rate over 5m window
-            {
-                record: `${sanitizedName}:error_rate_5m`,
-                expr: `rate(${sanitizedName}_errors_total[5m]) / rate(${sanitizedName}_requests_total[5m])`,
-            },
-            // p50, p95, p99 latency
-            {
-                record: `${sanitizedName}:latency_p50`,
-                expr: `histogram_quantile(0.50, rate(gen_ai_client_operation_duration_seconds_bucket{gen_ai_agent_name="${identity.name}"}[5m]))`,
-            },
-            {
-                record: `${sanitizedName}:latency_p95`,
-                expr: `histogram_quantile(0.95, rate(gen_ai_client_operation_duration_seconds_bucket{gen_ai_agent_name="${identity.name}"}[5m]))`,
-            },
-            {
-                record: `${sanitizedName}:latency_p99`,
-                expr: `histogram_quantile(0.99, rate(gen_ai_client_operation_duration_seconds_bucket{gen_ai_agent_name="${identity.name}"}[5m]))`,
-            },
-            // Cost per task (estimated from token usage)
-            {
-                record: `${sanitizedName}:cost_per_task_avg`,
-                expr: `rate(${sanitizedName}_cost_daily_total_dollars[5m]) / rate(${sanitizedName}_invocations_total{status="success"}[5m])`,
-            },
-            // Token budget utilization (percentage of daily limit used)
-            {
-                record: `${sanitizedName}:token_budget_utilization`,
-                expr: `increase(${sanitizedName}_tokens_daily_total[24h]) / ${constraints.maxTokensPerDay}`,
-            },
-            // Tool call success rate
-            {
-                record: `${sanitizedName}:tool_success_rate`,
-                expr: `rate(${sanitizedName}_tool_calls_total{status="success"}[5m]) / rate(${sanitizedName}_tool_calls_total[5m])`,
-            },
-        ];
-        if (isMultiAgent) {
-            rules.push({
-                record: `${sanitizedName}:handoff_rate_5m`,
-                expr: `rate(${sanitizedName}_team_handoffs_total[5m])`,
-            }, {
-                record: `${sanitizedName}:coordination_overhead_ratio`,
-                expr: `rate(${sanitizedName}_team_coordination_duration_seconds_sum[5m]) / rate(${sanitizedName}_invocation_duration_seconds_sum[5m])`,
-            });
-        }
-        return {
-            name: `${identity.name}_recording_rules`,
-            interval: '30s',
-            rules,
-        };
-    }
-    buildAlertRules(sanitizedName, identity, constraints, isMultiAgent) {
-        const rules = [
-            // High error rate
-            {
-                alert: `${identity.name}_HighErrorRate`,
-                expr: `${sanitizedName}:error_rate_5m > ${constraints.maxErrorRate}`,
-                for: '5m',
-                labels: {
-                    severity: 'critical',
-                    agent: identity.name,
-                },
-                annotations: {
-                    summary: `Agent ${identity.name} error rate exceeds ${constraints.maxErrorRate * 100}%`,
-                    description: `Error rate is {{ $value | humanizePercentage }} (threshold: ${constraints.maxErrorRate * 100}%).`,
-                    runbook_url: `https://runbooks.example.com/agents/${identity.name}/high-error-rate`,
-                },
-            },
-            // High latency (p95 exceeding SLO)
-            {
-                alert: `${identity.name}_HighLatency`,
-                expr: `${sanitizedName}:latency_p95 > ${constraints.maxLatencySeconds}`,
-                for: '5m',
-                labels: {
-                    severity: 'warning',
-                    agent: identity.name,
-                },
-                annotations: {
-                    summary: `Agent ${identity.name} p95 latency exceeds ${constraints.maxLatencySeconds}s`,
-                    description: `p95 latency is {{ $value | humanizeDuration }} (SLO: ${constraints.maxLatencySeconds}s).`,
-                },
-            },
-            // Token budget exhaustion (>80% of daily budget)
-            {
-                alert: `${identity.name}_TokenBudgetWarning`,
-                expr: `${sanitizedName}:token_budget_utilization > 0.8`,
-                for: '10m',
-                labels: {
-                    severity: 'warning',
-                    agent: identity.name,
-                },
-                annotations: {
-                    summary: `Agent ${identity.name} approaching token budget limit`,
-                    description: `Token budget utilization is {{ $value | humanizePercentage }} of daily limit (${constraints.maxTokensPerDay.toLocaleString()} tokens).`,
-                },
-            },
-            // Token budget exceeded
-            {
-                alert: `${identity.name}_TokenBudgetExceeded`,
-                expr: `${sanitizedName}:token_budget_utilization > 1.0`,
-                for: '1m',
-                labels: {
-                    severity: 'critical',
-                    agent: identity.name,
-                },
-                annotations: {
-                    summary: `Agent ${identity.name} has exceeded daily token budget`,
-                    description: `Token budget utilization is {{ $value | humanizePercentage }}. Limit: ${constraints.maxTokensPerDay.toLocaleString()} tokens/day.`,
-                },
-            },
-            // Cost threshold exceeded
-            {
-                alert: `${identity.name}_DailyCostExceeded`,
-                expr: `increase(${sanitizedName}_cost_daily_total_dollars[24h]) > ${constraints.maxCostPerDay}`,
-                for: '5m',
-                labels: {
-                    severity: 'critical',
-                    agent: identity.name,
-                },
-                annotations: {
-                    summary: `Agent ${identity.name} daily cost exceeds $${constraints.maxCostPerDay}`,
-                    description: 'Daily cost is ${{ $value | printf "%.2f" }}.',
-                },
-            },
-            // Agent down (no invocations in 15m)
-            {
-                alert: `${identity.name}_AgentDown`,
-                expr: `rate(${sanitizedName}_invocations_total[15m]) == 0`,
-                for: '15m',
-                labels: {
-                    severity: 'warning',
-                    agent: identity.name,
-                },
-                annotations: {
-                    summary: `Agent ${identity.name} has received no invocations in 15 minutes`,
-                    description: 'The agent may be down or unreachable.',
-                },
-            },
-            // Tool failure spike
-            {
-                alert: `${identity.name}_ToolFailureSpike`,
-                expr: `(1 - ${sanitizedName}:tool_success_rate) > 0.2`,
-                for: '5m',
-                labels: {
-                    severity: 'warning',
-                    agent: identity.name,
-                },
-                annotations: {
-                    summary: `Agent ${identity.name} tool failure rate exceeds 20%`,
-                    description: 'Tool success rate is {{ $value | humanizePercentage }}.',
-                },
-            },
-        ];
-        if (isMultiAgent) {
-            rules.push({
-                alert: `${identity.name}_HighCoordinationOverhead`,
-                expr: `${sanitizedName}:coordination_overhead_ratio > 0.3`,
-                for: '10m',
-                labels: {
-                    severity: 'warning',
-                    agent: identity.name,
-                },
-                annotations: {
-                    summary: `Agent ${identity.name} spending >30% of time on coordination`,
-                    description: 'Coordination overhead is {{ $value | humanizePercentage }}. Consider simplifying the team structure.',
-                },
-            }, {
-                alert: `${identity.name}_ExcessiveHandoffs`,
-                expr: `${sanitizedName}:handoff_rate_5m > 10`,
-                for: '5m',
-                labels: {
-                    severity: 'warning',
-                    agent: identity.name,
-                },
-                annotations: {
-                    summary: `Agent ${identity.name} team handoff rate exceeds 10/5m`,
-                    description: 'High handoff rate may indicate unclear task boundaries.',
-                },
-            });
-        }
-        return {
-            name: `${identity.name}_alert_rules`,
-            rules,
-        };
-    }
-    // ── Grafana Dashboard JSON ──────────────────────────────────────
-    generateDashboardJson(identity, constraints, tools, isMultiAgent) {
-        const dashboard = this.buildGrafanaDashboard(identity, constraints, tools, isMultiAgent);
-        return {
-            path: 'observability/dashboards/agent-health.json',
-            content: JSON.stringify(dashboard, null, 2),
-            type: 'config',
-            language: 'json',
-        };
-    }
-    buildGrafanaDashboard(identity, constraints, tools, isMultiAgent) {
-        const sanitizedName = identity.name.replace(/[^a-zA-Z0-9_]/g, '_');
-        const panels = [];
-        let panelId = 1;
-        let gridY = 0;
-        // ── Row: Overview ─────────────────────────────────
-        panels.push(this.createRow('Overview', gridY));
-        gridY += 1;
-        // Stat panels row
-        panels.push(this.createStatPanel(panelId++, 'Total Invocations', `sum(increase(${sanitizedName}_invocations_total[24h]))`, { x: 0, y: gridY, w: 4, h: 4 }, 'none', 'blue'));
-        panels.push(this.createStatPanel(panelId++, 'Active Invocations', `sum(${sanitizedName}_active_invocations)`, { x: 4, y: gridY, w: 4, h: 4 }, 'none', 'green'));
-        panels.push(this.createStatPanel(panelId++, 'Error Rate', `${sanitizedName}:error_rate_5m`, { x: 8, y: gridY, w: 4, h: 4 }, 'percentunit', 'red', [
-            { color: 'green', value: null },
-            { color: 'orange', value: constraints.maxErrorRate * 0.5 },
-            { color: 'red', value: constraints.maxErrorRate },
-        ]));
-        panels.push(this.createStatPanel(panelId++, 'p95 Latency', `${sanitizedName}:latency_p95`, { x: 12, y: gridY, w: 4, h: 4 }, 's', 'orange', [
-            { color: 'green', value: null },
-            { color: 'orange', value: constraints.maxLatencySeconds * 0.7 },
-            { color: 'red', value: constraints.maxLatencySeconds },
-        ]));
-        panels.push(this.createStatPanel(panelId++, 'Daily Cost', `increase(${sanitizedName}_cost_daily_total_dollars[24h])`, { x: 16, y: gridY, w: 4, h: 4 }, 'currencyUSD', 'purple', [
-            { color: 'green', value: null },
-            { color: 'orange', value: constraints.maxCostPerDay * 0.8 },
-            { color: 'red', value: constraints.maxCostPerDay },
-        ]));
-        panels.push(this.createStatPanel(panelId++, 'Token Budget Used', `${sanitizedName}:token_budget_utilization * 100`, { x: 20, y: gridY, w: 4, h: 4 }, 'percent', 'yellow', [
-            { color: 'green', value: null },
-            { color: 'orange', value: 80 },
-            { color: 'red', value: 100 },
-        ]));
-        gridY += 4;
-        // ── Row: Token Usage ──────────────────────────────
-        panels.push(this.createRow('Token Usage', gridY));
-        gridY += 1;
-        panels.push(this.createTimeSeriesPanel(panelId++, 'Token Usage Over Time', [
-            {
-                expr: `rate(gen_ai_usage_input_tokens_total{gen_ai_agent_name="${identity.name}"}[5m])`,
-                legendFormat: 'Input tokens/s',
-            },
-            {
-                expr: `rate(gen_ai_usage_output_tokens_total{gen_ai_agent_name="${identity.name}"}[5m])`,
-                legendFormat: 'Output tokens/s',
-            },
-        ], { x: 0, y: gridY, w: 12, h: 8 }, 'tokens/s'));
-        panels.push(this.createTimeSeriesPanel(panelId++, 'Cumulative Token Budget', [
-            {
-                expr: `increase(${sanitizedName}_tokens_daily_total[${this.buildRange('$__range')}])`,
-                legendFormat: 'Tokens used',
-            },
-            {
-                expr: `vector(${constraints.maxTokensPerDay})`,
-                legendFormat: 'Daily limit',
-            },
-        ], { x: 12, y: gridY, w: 12, h: 8 }, 'tokens'));
-        gridY += 8;
-        // ── Row: Latency ──────────────────────────────────
-        panels.push(this.createRow('Latency', gridY));
-        gridY += 1;
-        panels.push(this.createTimeSeriesPanel(panelId++, 'Latency Percentiles (p50 / p95 / p99)', [
-            {
-                expr: `${sanitizedName}:latency_p50`,
-                legendFormat: 'p50',
-            },
-            {
-                expr: `${sanitizedName}:latency_p95`,
-                legendFormat: 'p95',
-            },
-            {
-                expr: `${sanitizedName}:latency_p99`,
-                legendFormat: 'p99',
-            },
-            {
-                expr: `vector(${constraints.maxLatencySeconds})`,
-                legendFormat: 'SLO threshold',
-            },
-        ], { x: 0, y: gridY, w: 12, h: 8 }, 's'));
-        panels.push(this.createHeatmapPanel(panelId++, 'Latency Distribution', `sum(rate(gen_ai_client_operation_duration_seconds_bucket{gen_ai_agent_name="${identity.name}"}[5m])) by (le)`, { x: 12, y: gridY, w: 12, h: 8 }));
-        gridY += 8;
-        // ── Row: Cost ─────────────────────────────────────
-        panels.push(this.createRow('Cost Per Task', gridY));
-        gridY += 1;
-        panels.push(this.createTimeSeriesPanel(panelId++, 'Cost Per Request', [
-            {
-                expr: `rate(${sanitizedName}_cost_per_request_dollars_sum[5m]) / rate(${sanitizedName}_cost_per_request_dollars_count[5m])`,
-                legendFormat: 'Avg cost/request',
-            },
-            {
-                expr: `histogram_quantile(0.95, rate(${sanitizedName}_cost_per_request_dollars_bucket[5m]))`,
-                legendFormat: 'p95 cost/request',
-            },
-        ], { x: 0, y: gridY, w: 12, h: 8 }, 'currencyUSD'));
-        panels.push(this.createTimeSeriesPanel(panelId++, 'Daily Cost Accumulation', [
-            {
-                expr: `increase(${sanitizedName}_cost_daily_total_dollars[1h])`,
-                legendFormat: 'Hourly spend',
-            },
-            {
-                expr: `vector(${constraints.maxCostPerDay / 24})`,
-                legendFormat: 'Hourly budget',
-            },
-        ], { x: 12, y: gridY, w: 12, h: 8 }, 'currencyUSD'));
-        gridY += 8;
-        // ── Row: Error Rate ───────────────────────────────
-        panels.push(this.createRow('Error Rate', gridY));
-        gridY += 1;
-        panels.push(this.createTimeSeriesPanel(panelId++, 'Error Rate Over Time', [
-            {
-                expr: `${sanitizedName}:error_rate_5m`,
-                legendFormat: 'Error rate',
-            },
-            {
-                expr: `vector(${constraints.maxErrorRate})`,
-                legendFormat: 'SLO threshold',
-            },
-        ], { x: 0, y: gridY, w: 12, h: 8 }, 'percentunit'));
-        panels.push(this.createTimeSeriesPanel(panelId++, 'Errors by Type', [
-            {
-                expr: `sum by (error_type) (rate(${sanitizedName}_errors_total[5m]))`,
-                legendFormat: '{{ error_type }}',
-            },
-        ], { x: 12, y: gridY, w: 12, h: 8 }, 'ops'));
-        gridY += 8;
-        // ── Row: Tool Call Frequency ──────────────────────
-        panels.push(this.createRow('Tool Calls', gridY));
-        gridY += 1;
-        panels.push(this.createTimeSeriesPanel(panelId++, 'Tool Call Frequency', [
-            {
-                expr: `sum by (gen_ai_tool_name) (rate(${sanitizedName}_tool_calls_total[5m]))`,
-                legendFormat: '{{ gen_ai_tool_name }}',
-            },
-        ], { x: 0, y: gridY, w: 12, h: 8 }, 'ops'));
-        panels.push(this.createTimeSeriesPanel(panelId++, 'Tool Latency by Tool', [
-            {
-                expr: `histogram_quantile(0.95, sum by (gen_ai_tool_name, le) (rate(${sanitizedName}_tool_duration_seconds_bucket[5m])))`,
-                legendFormat: '{{ gen_ai_tool_name }} p95',
-            },
-        ], { x: 12, y: gridY, w: 12, h: 8 }, 's'));
-        gridY += 8;
-        // Per-tool breakdown table
-        if (tools.length > 0) {
-            panels.push(this.createTablePanel(panelId++, 'Tool Breakdown', [
-                {
-                    expr: `sum by (gen_ai_tool_name) (increase(${sanitizedName}_tool_calls_total[24h]))`,
-                    legendFormat: '{{ gen_ai_tool_name }}',
-                    format: 'table',
-                    instant: true,
-                },
-            ], { x: 0, y: gridY, w: 24, h: 6 }));
-            gridY += 6;
-        }
-        // ── Row: Multi-agent (conditional) ────────────────
-        if (isMultiAgent) {
-            panels.push(this.createRow('Team Coordination', gridY));
-            gridY += 1;
-            panels.push(this.createTimeSeriesPanel(panelId++, 'Handoff Rate', [
-                {
-                    expr: `sum by (source_agent, target_agent) (rate(${sanitizedName}_team_handoffs_total[5m]))`,
-                    legendFormat: '{{ source_agent }} -> {{ target_agent }}',
-                },
-            ], { x: 0, y: gridY, w: 12, h: 8 }, 'ops'));
-            panels.push(this.createTimeSeriesPanel(panelId++, 'Coordination Overhead', [
-                {
-                    expr: `${sanitizedName}:coordination_overhead_ratio`,
-                    legendFormat: 'Overhead ratio',
-                },
-                {
-                    expr: 'vector(0.3)',
-                    legendFormat: 'Threshold (30%)',
-                },
-            ], { x: 12, y: gridY, w: 12, h: 8 }, 'percentunit'));
-            gridY += 8;
-            panels.push(this.createTimeSeriesPanel(panelId++, 'Member Utilization', [
-                {
-                    expr: `${sanitizedName}_team_member_utilization_ratio`,
-                    legendFormat: '{{ gen_ai_agent_name }} ({{ role }})',
-                },
-            ], { x: 0, y: gridY, w: 24, h: 8 }, 'percentunit'));
-            gridY += 8;
-        }
-        return {
-            __inputs: [
-                {
-                    name: 'DS_PROMETHEUS',
-                    label: 'Prometheus',
-                    description: 'Prometheus data source for agent metrics',
-                    type: 'datasource',
-                    pluginId: 'prometheus',
-                    pluginName: 'Prometheus',
-                },
-            ],
-            __requires: [
-                { type: 'grafana', id: 'grafana', name: 'Grafana', version: '10.0.0' },
-                {
-                    type: 'datasource',
-                    id: 'prometheus',
-                    name: 'Prometheus',
-                    version: '1.0.0',
-                },
-                { type: 'panel', id: 'timeseries', name: 'Time series', version: '' },
-                { type: 'panel', id: 'stat', name: 'Stat', version: '' },
-                { type: 'panel', id: 'heatmap', name: 'Heatmap', version: '' },
-                { type: 'panel', id: 'table', name: 'Table', version: '' },
-                { type: 'panel', id: 'row', name: 'Row', version: '' },
-            ],
-            annotations: {
-                list: [
-                    {
-                        builtIn: 1,
-                        datasource: { type: 'grafana', uid: '-- Grafana --' },
-                        enable: true,
-                        hide: true,
-                        iconColor: 'rgba(0, 211, 255, 1)',
-                        name: 'Annotations & Alerts',
-                        type: 'dashboard',
-                    },
-                ],
-            },
-            description: `Health dashboard for OSSA agent: ${identity.name} (${identity.agentKind}, ${identity.pattern} pattern)`,
-            editable: true,
-            fiscalYearStartMonth: 0,
-            graphTooltip: 1, // Shared crosshair
-            id: null,
-            links: [],
-            panels,
-            schemaVersion: 39,
-            tags: [
-                'ossa',
-                'agent',
-                identity.name,
-                identity.agentType,
-                identity.pattern,
-            ],
-            templating: {
-                list: [
-                    {
-                        current: {
-                            selected: false,
-                            text: 'Prometheus',
-                            value: 'Prometheus',
-                        },
-                        hide: 0,
-                        includeAll: false,
-                        label: 'Data Source',
-                        multi: false,
-                        name: 'datasource',
-                        options: [],
-                        query: 'prometheus',
-                        queryValue: '',
-                        refresh: 1,
-                        regex: '',
-                        skipUrlSync: false,
-                        type: 'datasource',
-                    },
-                    {
-                        current: {
-                            selected: false,
-                            text: identity.name,
-                            value: identity.name,
-                        },
-                        hide: 2,
-                        label: 'Agent Name',
-                        name: 'agent_name',
-                        options: [
-                            { selected: true, text: identity.name, value: identity.name },
-                        ],
-                        query: identity.name,
-                        skipUrlSync: false,
-                        type: 'constant',
-                    },
-                ],
-            },
-            time: { from: 'now-6h', to: 'now' },
-            timepicker: {},
-            timezone: 'browser',
-            title: `${identity.name} - Agent Health`,
-            uid: `ossa-${sanitizedName}-health`,
-            version: 1,
-            refresh: '30s',
-        };
-    }
-    // ── Grafana panel builders ──────────────────────────────────────
-    createRow(title, gridY) {
-        return {
-            collapsed: false,
-            gridPos: { h: 1, w: 24, x: 0, y: gridY },
-            id: 1000 + gridY,
-            panels: [],
-            title,
-            type: 'row',
-        };
-    }
-    createStatPanel(id, title, expr, gridPos, unit, color, thresholds) {
-        return {
-            id,
-            title,
-            type: 'stat',
-            datasource: { type: 'prometheus', uid: '${datasource}' },
-            fieldConfig: {
-                defaults: {
-                    color: {
-                        mode: thresholds ? 'thresholds' : 'fixed',
-                        fixedColor: color,
-                    },
-                    mappings: [],
-                    thresholds: {
-                        mode: 'absolute',
-                        steps: thresholds ?? [{ color: color, value: null }],
-                    },
-                    unit,
-                },
-                overrides: [],
-            },
-            gridPos,
-            options: {
-                colorMode: thresholds ? 'background' : 'value',
-                graphMode: 'area',
-                justifyMode: 'auto',
-                orientation: 'auto',
-                reduceOptions: {
-                    calcs: ['lastNotNull'],
-                    fields: '',
-                    values: false,
-                },
-                textMode: 'auto',
-                wideLayout: true,
-            },
-            targets: [
-                {
-                    datasource: { type: 'prometheus', uid: '${datasource}' },
-                    expr,
-                    instant: true,
-                    legendFormat: '__auto',
-                    refId: 'A',
-                },
-            ],
-        };
-    }
-    createTimeSeriesPanel(id, title, queries, gridPos, unit) {
-        return {
-            id,
-            title,
-            type: 'timeseries',
-            datasource: { type: 'prometheus', uid: '${datasource}' },
-            fieldConfig: {
-                defaults: {
-                    color: { mode: 'palette-classic' },
-                    custom: {
-                        axisBorderShow: false,
-                        axisCenteredZero: false,
-                        axisColorMode: 'text',
-                        axisLabel: '',
-                        axisPlacement: 'auto',
-                        barAlignment: 0,
-                        drawStyle: 'line',
-                        fillOpacity: 10,
-                        gradientMode: 'none',
-                        hideFrom: { legend: false, tooltip: false, viz: false },
-                        insertNulls: false,
-                        lineInterpolation: 'smooth',
-                        lineWidth: 2,
-                        pointSize: 5,
-                        scaleDistribution: { type: 'linear' },
-                        showPoints: 'auto',
-                        spanNulls: false,
-                        stacking: { group: 'A', mode: 'none' },
-                        thresholdsStyle: { mode: 'off' },
-                    },
-                    mappings: [],
-                    thresholds: {
-                        mode: 'absolute',
-                        steps: [{ color: 'green', value: null }],
-                    },
-                    unit,
-                },
-                overrides: [],
-            },
-            gridPos,
-            options: {
-                legend: {
-                    calcs: ['mean', 'max', 'lastNotNull'],
-                    displayMode: 'table',
-                    placement: 'bottom',
-                    showLegend: true,
-                },
-                tooltip: { mode: 'multi', sort: 'desc' },
-            },
-            targets: queries.map((q, i) => ({
-                datasource: { type: 'prometheus', uid: '${datasource}' },
-                expr: q.expr,
-                legendFormat: q.legendFormat,
-                refId: String.fromCharCode(65 + i), // A, B, C, ...
-            })),
-        };
-    }
-    createHeatmapPanel(id, title, expr, gridPos) {
-        return {
-            id,
-            title,
-            type: 'heatmap',
-            datasource: { type: 'prometheus', uid: '${datasource}' },
-            gridPos,
-            options: {
-                calculate: false,
-                cellGap: 1,
-                color: {
-                    exponent: 0.5,
-                    fill: 'dark-orange',
-                    mode: 'scheme',
-                    reverse: false,
-                    scale: 'exponential',
-                    scheme: 'Oranges',
-                    steps: 64,
-                },
-                exemplars: { color: 'rgba(255,0,255,0.7)' },
-                filterValues: { le: 1e-9 },
-                legend: { show: true },
-                rowsFrame: { layout: 'le' },
-                showValue: 'auto',
-                tooltip: { mode: 'single', showColorScale: false, yHistogram: false },
-                yAxis: {
-                    axisPlacement: 'left',
-                    reverse: false,
-                    unit: 's',
-                },
-            },
-            targets: [
-                {
-                    datasource: { type: 'prometheus', uid: '${datasource}' },
-                    expr,
-                    format: 'heatmap',
-                    legendFormat: '{{ le }}',
-                    refId: 'A',
-                },
-            ],
-        };
-    }
-    createTablePanel(id, title, queries, gridPos) {
-        return {
-            id,
-            title,
-            type: 'table',
-            datasource: { type: 'prometheus', uid: '${datasource}' },
-            fieldConfig: {
-                defaults: {
-                    color: { mode: 'thresholds' },
-                    custom: {
-                        align: 'auto',
-                        cellOptions: { type: 'auto' },
-                        inspect: false,
-                    },
-                    mappings: [],
-                    thresholds: {
-                        mode: 'absolute',
-                        steps: [
-                            { color: 'green', value: null },
-                            { color: 'red', value: 80 },
-                        ],
-                    },
-                },
-                overrides: [
-                    {
-                        matcher: { id: 'byName', options: 'gen_ai_tool_name' },
-                        properties: [{ id: 'displayName', value: 'Tool' }],
-                    },
-                    {
-                        matcher: { id: 'byName', options: 'Value' },
-                        properties: [{ id: 'displayName', value: 'Calls (24h)' }],
-                    },
-                ],
-            },
-            gridPos,
-            options: {
-                cellHeight: 'sm',
-                footer: { countRows: false, fields: '', reducer: ['sum'], show: true },
-                showHeader: true,
-                sortBy: [{ desc: true, displayName: 'Calls (24h)' }],
-            },
-            targets: queries.map((q, i) => ({
-                datasource: { type: 'prometheus', uid: '${datasource}' },
-                expr: q.expr,
-                format: q.format,
-                instant: q.instant,
-                legendFormat: q.legendFormat,
-                refId: String.fromCharCode(65 + i),
-            })),
-            transformations: [
-                {
-                    id: 'merge',
-                    options: {},
-                },
-                {
-                    id: 'organize',
-                    options: {
-                        excludeByName: { Time: true, __name__: true },
-                        indexByName: {},
-                        renameByName: {},
-                    },
-                },
-            ],
-        };
-    }
-    /**
-     * Build a range expression for PromQL that works with Grafana variables.
-     * Falls back to a static range if no variable is available.
-     */
-    buildRange(variable) {
-        return variable;
-    }
-}
-//# sourceMappingURL=observability-generator.service.js.map