@meyicloud/meyi-cost-server 1.5.0 → 1.7.0

package/src/services/cost-analyser.service.js

@@ -0,0 +1,256 @@
+import {
+  DescribeTasksCommand,
+  ECSClient,
+  RunTaskCommand,
+  StopTaskCommand,
+} from "@aws-sdk/client-ecs";
+import { GetObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import {
+  CreateSecretCommand,
+  DeleteSecretCommand,
+  SecretsManagerClient,
+} from "@aws-sdk/client-secrets-manager";
+import { truthy } from "../lib/cost-utils.js";
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const list = (value) => String(value || "").split(",").map((item) => item.trim()).filter(Boolean);
+
+function normalizeProvider(value) {
+  const name = String(value || "").trim().toLowerCase();
+  if (name.includes("bedrock")) return "bedrock";
+  if (name.includes("anthropic") || name.includes("claude")) return "anthropic";
+  if (name.includes("openai") || name.includes("gpt")) return "openai";
+  return name;
+}
+
+function required(value, name) {
+  const text = String(value || "").trim();
+  if (!text) throw Object.assign(new Error(`${name} is required for external cost analysis`), { name: "CostAnalyserConfigError", statusCode: 503 });
+  return text;
+}
+
+function environment(values) {
+  return Object.entries(values).filter(([, value]) => value !== undefined && value !== null && value !== "").map(([name, value]) => ({ name, value: String(value) }));
+}
+
+async function bodyText(body) {
+  if (!body) return "";
+  if (typeof body.transformToString === "function") return body.transformToString();
+  const chunks = [];
+  for await (const chunk of body) chunks.push(Buffer.from(chunk));
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+export class CostAnalyserService {
+  constructor({ contextService, athenaContextService, providerResolver = null, logger = console, env = process.env, ecsClient = null, s3Client = null, secretsClient = null } = {}) {
+    this.contextService = contextService;
+    this.athenaContextService = athenaContextService;
+    this.providerResolver = providerResolver;
+    this.logger = logger;
+    this.enabled = truthy(env.COST_AI_ENABLED);
+    this.region = String(env.COST_AI_ANALYSER_REGION || env.AWS_REGION || env.AWS_DEFAULT_REGION || "us-east-1");
+    this.cluster = String(env.COST_AI_ANALYSER_CLUSTER || "").trim();
+    this.taskDefinition = String(env.COST_AI_ANALYSER_TASK_DEFINITION || "").trim();
+    this.containerName = String(env.COST_AI_ANALYSER_CONTAINER_NAME || "cost-ai-analyser").trim();
+    this.subnets = list(env.COST_AI_ANALYSER_SUBNETS);
+    this.securityGroups = list(env.COST_AI_ANALYSER_SECURITY_GROUPS);
+    this.assignPublicIp = truthy(env.COST_AI_ANALYSER_ASSIGN_PUBLIC_IP) ? "ENABLED" : "DISABLED";
+    this.reportBucket = String(env.COST_AI_ANALYSER_REPORT_BUCKET || "").trim();
+    this.targetRegions = String(env.COST_AI_ANALYSER_TARGET_REGIONS || env.AWS_REGION || "us-east-1").trim();
+    this.providerSecretPrefix = String(env.COST_AI_ANALYSER_PROVIDER_SECRET_PREFIX || "").trim().replace(/\/+$/, "");
+    this.topServices = String(env.COST_AI_ANALYSER_TOP_N_SERVICES || "10").trim();
+    this.pollMs = Math.max(Number(env.COST_AI_ANALYSER_POLL_INTERVAL_MS || 15_000), 2_000);
+    this.timeoutMs = Math.max(Number(env.COST_AI_ANALYSER_TIMEOUT_MS || 45 * 60_000), 60_000);
+    this.ecs = ecsClient || new ECSClient({ region: this.region });
+    this.s3 = s3Client || new S3Client({ region: this.region });
+    this.secrets = secretsClient || new SecretsManagerClient({ region: this.region });
+  }
+
+  infrastructureConfigured() {
+    return Boolean(this.cluster && this.taskDefinition && this.subnets.length && this.securityGroups.length && this.reportBucket && this.providerSecretPrefix);
+  }
+
+  async resolveProvider(tenantId) {
+    if (!this.providerResolver) {
+      throw Object.assign(new Error("Meyi Connect AI provider resolution is not configured"), { name: "CostAiProviderResolverError", statusCode: 503 });
+    }
+    const resolved = await this.providerResolver(tenantId);
+    if (!resolved) {
+      throw Object.assign(new Error("Configure an active AI provider before enabling AI cost reports"), { name: "CostAiProviderNotConfiguredError", statusCode: 409 });
+    }
+    const provider = normalizeProvider(resolved.provider);
+    if (!["bedrock", "anthropic", "openai"].includes(provider)) {
+      throw Object.assign(new Error(`Unsupported AI provider "${resolved.provider}"`), { name: "CostAiProviderConfigError", statusCode: 400 });
+    }
+    const modelId = required(resolved.modelId, "active AI provider model ID");
+    if ((provider === "anthropic" || provider === "openai") && !resolved.apiKey) {
+      throw Object.assign(new Error(`${provider} requires an API key in the active AI provider`), { name: "CostAiProviderConfigError", statusCode: 400 });
+    }
+    if (provider === "bedrock" && !resolved.region) {
+      throw Object.assign(new Error("Bedrock requires an AWS region in the active AI provider"), { name: "CostAiProviderConfigError", statusCode: 400 });
+    }
+    if (Boolean(resolved.accessKeyId) !== Boolean(resolved.secretAccessKey)) {
+      throw Object.assign(new Error("The active Bedrock provider must contain both AWS access-key fields"), { name: "CostAiProviderConfigError", statusCode: 400 });
+    }
+    return { ...resolved, provider, modelId, source: "tenant-configuration" };
+  }
+
+  async status(req) {
+    const configured = this.infrastructureConfigured();
+    if (!this.enabled || !configured) {
+      return { enabled: false, providerConfigured: false, provider: null, modelId: null, region: null, source: null, reason: this.enabled ? "ANALYSER_NOT_CONFIGURED" : "COST_AI_DISABLED" };
+    }
+    try {
+      const tenantId = this.contextService.tenantId(req);
+      const provider = await this.resolveProvider(tenantId);
+      return { enabled: true, providerConfigured: true, provider: provider.provider, modelId: provider.modelId, region: provider.region || null, source: provider.source };
+    } catch (error) {
+      if (error.name !== "CostAiProviderNotConfiguredError") throw error;
+      return { enabled: false, providerConfigured: false, provider: null, modelId: null, region: null, source: null, reason: "AI_PROVIDER_REQUIRED" };
+    }
+  }
+
+  async createProviderSecret({ tenantId, reportId, provider }) {
+    const response = await this.secrets.send(new CreateSecretCommand({
+      Name: `${this.providerSecretPrefix}/${reportId}`,
+      Description: "Temporary provider configuration for one Meyi cost-analysis task",
+      SecretString: JSON.stringify({
+        provider: provider.provider,
+        modelId: provider.modelId,
+        apiKey: provider.apiKey,
+        authType: provider.authType,
+        region: provider.region,
+        accessKeyId: provider.accessKeyId,
+        secretAccessKey: provider.secretAccessKey,
+      }),
+      Tags: [
+        { Key: "Application", Value: "meyi-connect" },
+        { Key: "Component", Value: "cost-ai-analyser" },
+        { Key: "TenantId", Value: String(tenantId).slice(0, 256) },
+        { Key: "ReportId", Value: String(reportId).slice(0, 256) },
+      ],
+    }));
+    return required(response.ARN, "temporary AI provider secret ARN");
+  }
+
+  async deleteProviderSecret(secretArn) {
+    if (!secretArn) return;
+    try {
+      await this.secrets.send(new DeleteSecretCommand({ SecretId: secretArn, ForceDeleteWithoutRecovery: true }));
+    } catch (error) {
+      if (error?.name === "ResourceNotFoundException") return;
+      this.logger.error?.("[Cost AI Reports] Failed to delete temporary provider secret", { secretArn, message: error.message });
+    }
+  }
+
+  statusSummary(provider) {
+    return {
+      provider: provider.provider,
+      modelId: provider.modelId,
+      region: provider.region || null,
+      source: provider.source,
+    };
+  }
+
+  validate() {
+    if (!this.enabled) throw Object.assign(new Error("AI cost analysis is not enabled for this deployment"), { name: "CostAiDisabledError", statusCode: 503 });
+    required(this.cluster, "COST_AI_ANALYSER_CLUSTER");
+    required(this.taskDefinition, "COST_AI_ANALYSER_TASK_DEFINITION");
+    if (!this.subnets.length) required("", "COST_AI_ANALYSER_SUBNETS");
+    if (!this.securityGroups.length) required("", "COST_AI_ANALYSER_SECURITY_GROUPS");
+    required(this.reportBucket, "COST_AI_ANALYSER_REPORT_BUCKET");
+    required(this.providerSecretPrefix, "COST_AI_ANALYSER_PROVIDER_SECRET_PREFIX");
+  }
+
+  async readJson(key) {
+    const response = await this.s3.send(new GetObjectCommand({ Bucket: this.reportBucket, Key: key }));
+    return JSON.parse(await bodyText(response.Body));
+  }
+
+  async execute({ tenantId, reportId, range, frequency, onStarted = null }) {
+    this.validate();
+    const provider = await this.resolveProvider(tenantId);
+    const customer = await this.contextService.resolve({ headers: {}, user: { tenant_id: tenantId, tenantId } });
+    const athena = this.athenaContextService.resolve(customer).config;
+    if (!athena.enabled) throw Object.assign(new Error("CUR discovery has not produced a queryable Athena table for this tenant"), { name: "CurDataNotReadyError", statusCode: 503 });
+    const targetRoleArn = required(customer.meta?.payerRoleArn, "customer TARGET_ROLE_ARN");
+    const targetAccountId = required(customer.meta?.managementAccountId || customer.accounts?.[0]?.id, "customer management account ID");
+    const prefix = `tenants/${tenantId}/reports/${reportId}`;
+    let providerSecretArn;
+    try {
+      providerSecretArn = await this.createProviderSecret({ tenantId, reportId, provider });
+      const values = {
+        REPORT_JOB_ID: reportId,
+        REPORT_TENANT_ID: tenantId,
+        REPORT_KEY_PREFIX: prefix,
+        REPORT_START_DATE: range.Start,
+        REPORT_END_DATE: range.End,
+        REPORT_FREQUENCY: frequency,
+        REPORT_BUCKET: this.reportBucket,
+        REPORT_BUCKET_REGION: this.region,
+        TARGET_ACCOUNT_ID: targetAccountId,
+        TARGET_ROLE_ARN: targetRoleArn,
+        TARGET_ROLE_EXTERNAL_ID: customer.meta?.externalId,
+        TARGET_REGIONS: this.targetRegions,
+        COST_CUR_DATABASE: athena.database,
+        COST_CUR_TABLE: athena.table,
+        COST_CUR_WORKGROUP: athena.workgroup,
+        COST_CUR_OUTPUT_LOCATION: athena.outputLocation,
+        COST_CUR_REGION: athena.region,
+        COST_CUR_TENANT_COLUMN: athena.tenantColumn,
+        COST_CUR_TENANT_PARTITION: athena.tenantPartition || tenantId,
+        AI_PROVIDER_SECRET_ARN: providerSecretArn,
+        AI_PROVIDER_SECRET_REGION: this.region,
+        TOP_N_SERVICES: this.topServices,
+      };
+      const launched = await this.ecs.send(new RunTaskCommand({
+        cluster: this.cluster,
+        taskDefinition: this.taskDefinition,
+        launchType: "FARGATE",
+        count: 1,
+        enableExecuteCommand: false,
+        networkConfiguration: { awsvpcConfiguration: { subnets: this.subnets, securityGroups: this.securityGroups, assignPublicIp: this.assignPublicIp } },
+        overrides: { containerOverrides: [{ name: this.containerName, environment: environment(values) }] },
+        startedBy: `meyi-cost-${reportId}`.slice(0, 36),
+      }));
+      if (launched.failures?.length || !launched.tasks?.[0]?.taskArn) {
+        const reason = launched.failures?.map((item) => item.reason || item.detail).filter(Boolean).join("; ") || "ECS did not return a task ARN";
+        throw Object.assign(new Error(`Unable to start cost analyser: ${reason}`), { name: "CostAnalyserLaunchError", statusCode: 502 });
+      }
+      const taskArn = launched.tasks[0].taskArn;
+      await onStarted?.(taskArn);
+      const deadline = Date.now() + this.timeoutMs;
+      while (Date.now() < deadline) {
+        const response = await this.ecs.send(new DescribeTasksCommand({ cluster: this.cluster, tasks: [taskArn] }));
+        const task = response.tasks?.[0];
+        if (task?.lastStatus === "STOPPED") {
+          const container = task.containers?.find((item) => item.name === this.containerName) || task.containers?.[0];
+          let status;
+          try { status = await this.readJson(`${prefix}/status.json`); } catch { status = null; }
+          if (Number(container?.exitCode ?? 1) !== 0 || status?.status !== "COMPLETED") {
+            throw Object.assign(new Error(status?.error || container?.reason || task.stoppedReason || "Cost analyser task failed"), { name: "CostAnalyserTaskError", statusCode: 502, taskArn });
+          }
+          return {
+            taskArn,
+            artifactBucket: this.reportBucket,
+            markdownKey: status.markdownKey || `${prefix}/report.md`,
+            pdfKey: status.pdfKey || `${prefix}/report.pdf`,
+            ticketsKey: status.ticketsKey || `${prefix}/tickets.json`,
+            ticketCount: Number(status.summary?.ticketCount || 0),
+            markdownSize: Number(status.markdownSize || 0),
+            pdfSize: Number(status.pdfSize || 0),
+            ...this.statusSummary(provider),
+            dataSource: "AWS CUR",
+            facts: { currentTotal: Number(status.summary?.totalMonthlyCost || 0), currency: "USD" },
+            summary: status.summary || {},
+          };
+        }
+        await sleep(this.pollMs);
+      }
+      await this.ecs.send(new StopTaskCommand({ cluster: this.cluster, task: taskArn, reason: "Meyi cost analysis timeout" }));
+      throw Object.assign(new Error("Cost analyser task timed out"), { name: "CostAnalyserTimeoutError", statusCode: 504, taskArn });
+    } finally {
+      await this.deleteProviderSecret(providerSecretArn);
+    }
+  }
+}

package/src/services/cost-analysis-report.service.js

@@ -9,19 +9,20 @@ function reportDto(row) {
   return {
     id: row.id, frequency: row.schedule_frequency, scheduledFor: row.scheduled_for,
     period: { Start: String(row.period_start).slice(0, 10), End: String(row.period_end).slice(0, 10) },
-    status: row.status, attempts: Number(row.attempt_count || 0), modelId: row.model_id,
+    status: row.status, attempts: Number(row.attempt_count || 0), provider: row.provider_name,
+    providerSource: row.provider_source, modelId: row.model_id,
     dataSource: row.data_source, facts: row.facts || null, ...(row.result || {}),
-    pdfReady: row.status === "COMPLETED" && Number(row.pdf_size || 0) > 0,
+    pdfReady: row.status === "COMPLETED" && Boolean(row.pdf_key || row.pdf_data || Number(row.pdf_size || 0) > 0),
     pdfSize: Number(row.pdf_size || 0), error: row.error, startedAt: row.started_at,
     completedAt: row.completed_at, createdAt: row.created_at,
   };
 }
 
 export class CostAnalysisReportService {
-  constructor({ contextService, repository, analysisService }) {
+  constructor({ contextService, repository, artifactService }) {
     this.contextService = contextService;
     this.repository = repository;
-    this.analysisService = analysisService;
+    this.artifactService = artifactService;
   }
 
   tenant(req) { return this.contextService.tenantId(req); }
@@ -37,6 +38,11 @@ export class CostAnalysisReportService {
 
   async list(req, limit) { return (await this.repository.list(this.tenant(req), limit)).map(reportDto); }
 
+  async latest(req) {
+    const reports = await this.list(req, 1);
+    return reports[0] || null;
+  }
+
   async get(req, id) {
     const row = await this.repository.find(this.tenant(req), id);
     if (!row) throw Object.assign(new Error("AI cost report was not found"), { statusCode: 404 });
@@ -46,7 +52,18 @@ export class CostAnalysisReportService {
   async pdf(req, id) {
     const row = await this.repository.find(this.tenant(req), id, true);
     if (!row) throw Object.assign(new Error("AI cost report was not found"), { statusCode: 404 });
-    if (row.status !== "COMPLETED" || !row.pdf_data) throw Object.assign(new Error("The PDF is not ready"), { statusCode: 409 });
-    return { data: Buffer.from(row.pdf_data), filename: `meyi-cost-analysis-${String(row.period_start).slice(0, 10)}-${id.slice(0, 8)}.pdf` };
+    if (row.status !== "COMPLETED") throw Object.assign(new Error("The PDF is not ready"), { statusCode: 409 });
+    const data = row.pdf_key ? await this.artifactService.get(row.artifact_bucket, row.pdf_key) : row.pdf_data ? Buffer.from(row.pdf_data) : null;
+    if (!data?.length) throw Object.assign(new Error("The PDF artifact is unavailable"), { statusCode: 409 });
+    return { data, filename: `meyi-cost-analysis-${String(row.period_start).slice(0, 10)}-${id.slice(0, 8)}.pdf` };
+  }
+
+  async markdown(req, id) {
+    const row = await this.repository.find(this.tenant(req), id, true);
+    if (!row) throw Object.assign(new Error("AI cost report was not found"), { statusCode: 404 });
+    if (row.status !== "COMPLETED" || !row.markdown_key) throw Object.assign(new Error("The Markdown report is not ready"), { statusCode: 409 });
+    const data = await this.artifactService.get(row.artifact_bucket, row.markdown_key);
+    if (!data?.length) throw Object.assign(new Error("The Markdown artifact is unavailable"), { statusCode: 409 });
+    return { data, filename: `meyi-cost-analysis-${String(row.period_start).slice(0, 10)}-${id.slice(0, 8)}.md` };
   }
 }

package/src/services/cost-report-artifact.service.js

@@ -0,0 +1,22 @@
+import { GetObjectCommand, S3Client } from "@aws-sdk/client-s3";
+
+async function bytes(body) {
+  if (!body) return Buffer.alloc(0);
+  if (typeof body.transformToByteArray === "function") return Buffer.from(await body.transformToByteArray());
+  const chunks = [];
+  for await (const chunk of body) chunks.push(Buffer.from(chunk));
+  return Buffer.concat(chunks);
+}
+
+export class CostReportArtifactService {
+  constructor({ client = null, region = process.env.COST_AI_ANALYSER_REGION || process.env.AWS_REGION } = {}) {
+    this.client = client || new S3Client({ region });
+  }
+
+  async get(bucket, key) {
+    if (!bucket || !key) return null;
+    const response = await this.client.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+    return bytes(response.Body);
+  }
+}
+

package/src/workers/cost-analysis-report.worker.js

@@ -1,12 +1,9 @@
 import { nextScheduleRun, reportRange } from "../lib/cost-analysis-schedule.js";
-import { createCostAnalysisPdf } from "../services/cost-analysis-pdf.service.js";
-
 export class CostAnalysisReportWorker {
-  constructor({ repository, analysisService, logger = console, env = process.env, pdfGenerator = createCostAnalysisPdf }) {
+  constructor({ repository, analyserService, logger = console, env = process.env }) {
     this.repository = repository;
-    this.analysisService = analysisService;
+    this.analyserService = analyserService;
     this.logger = logger;
-    this.pdfGenerator = pdfGenerator;
     this.enabled = String(env.COST_AI_ENABLED || "").toLowerCase() === "true";
     this.pollMs = Math.max(Number(env.COST_AI_REPORT_POLL_INTERVAL_MS || 60_000), 10_000);
     this.leaseMs = Math.max(Number(env.COST_AI_REPORT_LEASE_MS || 30 * 60_000), 60_000);
@@ -25,10 +22,14 @@ export class CostAnalysisReportWorker {
     const claimed = await this.repository.markRunning(report.id);
     if (!claimed) return this.repository.setNextRun(schedule.tenant_id, nextRunAt, false, schedule.next_run_at);
     try {
-      const req = { body: { force: true }, headers: {}, user: { tenant_id: schedule.tenant_id, tenantId: schedule.tenant_id } };
-      const analysis = await this.analysisService.analyze(req, range);
-      const pdf = await this.pdfGenerator(analysis);
-      await this.repository.complete(report.id, analysis, pdf);
+      const result = await this.analyserService.execute({
+        tenantId: schedule.tenant_id,
+        reportId: report.id,
+        range,
+        frequency: schedule.frequency,
+        onStarted: (taskArn) => this.repository.setTaskArn(report.id, taskArn),
+      });
+      await this.repository.completeExternal(report.id, result);
       await this.repository.setNextRun(schedule.tenant_id, nextRunAt, true, schedule.next_run_at);
     } catch (error) {
       await this.repository.fail(report.id, error);

package/src/lib/cost-analysis.js

@@ -1,116 +0,0 @@
-import { createHash } from "node:crypto";
-import { round } from "./cost-utils.js";
-
-const text = (value, max = 1200) => String(value || "").trim().slice(0, max);
-const severity = (value) => ["low", "medium", "high"].includes(value) ? value : "medium";
-
-function median(values) {
-  const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
-  if (!sorted.length) return null;
-  const middle = Math.floor(sorted.length / 2);
-  return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
-}
-
-function deltaRows(current = [], previous = [], limit = 8) {
-  const before = new Map(previous.map((item) => [item.label, Number(item.amount || 0)]));
-  return current.slice(0, limit).map((item) => {
-    const currentAmount = Number(item.amount || 0);
-    const previousAmount = before.get(item.label) || 0;
-    return {
-      label: text(item.label, 160),
-      current: round(currentAmount),
-      previous: round(previousAmount),
-      change: round(currentAmount - previousAmount),
-      changePercentage: previousAmount > 0 ? round((currentAmount - previousAmount) / previousAmount * 100) : null,
-      sharePercentage: Number.isFinite(Number(item.percentage)) ? round(Number(item.percentage)) : null,
-    };
-  }).sort((a, b) => Math.abs(b.change) - Math.abs(a.change));
-}
-
-export function buildCostFacts({ current, previous }) {
-  const currentTotal = round(current.totalCost || 0);
-  const previousTotal = round(previous.totalCost || 0);
-  const change = round(currentTotal - previousTotal);
-  const changePercentage = previousTotal > 0 ? round(change / previousTotal * 100) : null;
-  const historicalTotals = (current.trends || [])
-    .filter((item) => String(item.month || "") < String(current.period?.Start || ""))
-    .map((item) => Number(item.amount || 0))
-    .filter((value) => value > 0);
-  const baseline = median(historicalTotals);
-  const currentVsBaseline = baseline && baseline > 0 ? round((currentTotal - baseline) / baseline * 100) : null;
-  const serviceChanges = deltaRows(current.topServices, previous.topServices);
-  const accountChanges = deltaRows(current.topAccounts, previous.topAccounts, 6);
-  const topServiceShare = Number(current.topServices?.[0]?.percentage || 0);
-  const calculatedSignals = [];
-
-  if (changePercentage != null && Math.abs(changePercentage) >= 10) {
-    calculatedSignals.push({
-      severity: Math.abs(changePercentage) >= 25 ? "high" : "medium",
-      kind: "period_change",
-      message: `Spend ${changePercentage > 0 ? "increased" : "decreased"} ${Math.abs(changePercentage)}% compared with the preceding period.`,
-    });
-  }
-  if (currentVsBaseline != null && currentVsBaseline >= 25 && historicalTotals.length >= 3) {
-    calculatedSignals.push({ severity: "high", kind: "baseline_anomaly", message: `Spend is ${currentVsBaseline}% above the historical monthly median.` });
-  }
-  if (topServiceShare >= 50) {
-    calculatedSignals.push({ severity: "medium", kind: "service_concentration", message: `${text(current.topServices[0]?.label, 160)} represents ${round(topServiceShare)}% of spend.` });
-  }
-
-  return {
-    period: current.period,
-    comparisonPeriod: previous.period,
-    currency: current.currency || "USD",
-    dataSource: current.dataSource,
-    currentTotal,
-    previousTotal,
-    change,
-    changePercentage,
-    activeAccounts: Number(current.activeAccounts || 0),
-    activeResources: current.activeResources == null ? null : Number(current.activeResources),
-    historyMonths: historicalTotals.length,
-    historicalMonthlyMedian: baseline == null ? null : round(baseline),
-    currentVsBaselinePercentage: currentVsBaseline,
-    serviceChanges,
-    accountChanges,
-    topRegions: (current.topRegions || []).slice(0, 6).map((item) => ({ label: text(item.label, 160), amount: round(item.amount || 0), sharePercentage: round(item.percentage || 0) })),
-    calculatedSignals,
-    limitations: historicalTotals.length < 3 ? ["Fewer than three non-zero monthly data points are available, so anomaly confidence is limited."] : [],
-  };
-}
-
-export function redactFactsForModel(facts) {
-  return {
-    ...facts,
-    accountChanges: facts.accountChanges.map((item, index) => ({ ...item, label: `Account ${index + 1}` })),
-  };
-}
-
-export function analysisFingerprint(facts, modelId) {
-  return createHash("sha256").update(JSON.stringify({ facts, modelId })).digest("hex");
-}
-
-export function parseAnalysisResponse(value) {
-  const raw = String(value || "").trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "");
-  const start = raw.indexOf("{");
-  const end = raw.lastIndexOf("}");
-  if (start < 0 || end <= start) throw new Error("The AI response did not contain a JSON object");
-  const parsed = JSON.parse(raw.slice(start, end + 1));
-  const summary = text(parsed.summary, 3000);
-  const findings = Array.isArray(parsed.findings) ? parsed.findings.slice(0, 6).map((item) => ({
-    severity: severity(item?.severity),
-    title: text(item?.title, 160),
-    explanation: text(item?.explanation, 1000),
-    evidence: text(item?.evidence, 500),
-    estimatedImpact: Number.isFinite(Number(item?.estimatedImpact)) ? round(Number(item.estimatedImpact)) : null,
-  })).filter((item) => item.title && item.explanation) : [];
-  const recommendations = Array.isArray(parsed.recommendations) ? parsed.recommendations.slice(0, 6).map((item) => ({
-    priority: Math.min(Math.max(Number(item?.priority) || 2, 1), 3),
-    title: text(item?.title, 160),
-    action: text(item?.action, 800),
-    rationale: text(item?.rationale, 600),
-  })).filter((item) => item.title && item.action) : [];
-  const limitations = Array.isArray(parsed.limitations) ? parsed.limitations.slice(0, 5).map((item) => text(item, 400)).filter(Boolean) : [];
-  if (!summary || !findings.length || !recommendations.length) throw new Error("The AI response was missing required analysis fields");
-  return { summary, findings, recommendations, limitations };
-}