@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-FCNAS3W2.js

@@ -0,0 +1,1033 @@
+import {
+  globalScope
+} from "./chunk-GAFJEYLK.js";
+import {
+  canonicalizeVariantIdentifier
+} from "./chunk-YWNAHW24.js";
+import {
+  parseJsonWithContext
+} from "./chunk-QVZMFDYG.js";
+import {
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+
+// src/telemetry/unified-telemetry.ts
+import { createReadStream } from "fs";
+import { createInterface } from "readline/promises";
+
+// src/telemetry/cost-dimensions.ts
+var COST_TOLERANCE_ABSOLUTE = 1e-4;
+var COST_TOLERANCE_RELATIVE = 1e-3;
+function validateCostDimensions(cost) {
+  const errors = [];
+  if (!cost.provider || typeof cost.provider !== "string") {
+    errors.push("provider must be a non-empty string");
+  }
+  if (!cost.model || typeof cost.model !== "string") {
+    errors.push("model must be a non-empty string");
+  }
+  if (!cost.currency || typeof cost.currency !== "string") {
+    errors.push("currency must be a non-empty string");
+  }
+  if (typeof cost.inputTokens !== "number" || cost.inputTokens < 0) {
+    errors.push("inputTokens must be a non-negative number");
+  }
+  if (typeof cost.outputTokens !== "number" || cost.outputTokens < 0) {
+    errors.push("outputTokens must be a non-negative number");
+  }
+  if (typeof cost.totalCost !== "number" || cost.totalCost < 0) {
+    errors.push("totalCost must be a non-negative number");
+  }
+  if (typeof cost.timestamp !== "number" || cost.timestamp <= 0) {
+    errors.push("timestamp must be a positive number");
+  }
+  if (cost.cacheReadTokens !== void 0) {
+    if (typeof cost.cacheReadTokens !== "number" || cost.cacheReadTokens < 0) {
+      errors.push("cacheReadTokens must be a non-negative number");
+    }
+  }
+  if (cost.cacheWriteTokens !== void 0) {
+    if (typeof cost.cacheWriteTokens !== "number" || cost.cacheWriteTokens < 0) {
+      errors.push("cacheWriteTokens must be a non-negative number");
+    }
+  }
+  if (cost.cacheCost !== void 0) {
+    if (typeof cost.cacheCost !== "number" || cost.cacheCost < 0) {
+      errors.push("cacheCost must be a non-negative number");
+    }
+  }
+  if (cost.toolCosts !== void 0) {
+    if (typeof cost.toolCosts !== "number" || cost.toolCosts < 0) {
+      errors.push("toolCosts must be a non-negative number");
+    }
+  }
+  if (cost.infrastructureCost !== void 0) {
+    if (typeof cost.infrastructureCost !== "number" || cost.infrastructureCost < 0) {
+      errors.push("infrastructureCost must be a non-negative number");
+    }
+  }
+  if (cost.costBreakdown) {
+    const breakdown = cost.costBreakdown;
+    const breakdownComponents = [
+      ["inputCost", breakdown.inputCost],
+      ["outputCost", breakdown.outputCost],
+      ["cacheCost", breakdown.cacheCost],
+      ["toolCosts", breakdown.toolCosts],
+      ["infrastructureCost", breakdown.infrastructureCost]
+    ];
+    for (const [name, value] of breakdownComponents) {
+      if (value !== void 0 && (typeof value !== "number" || value < 0)) {
+        errors.push(`costBreakdown.${name} must be a non-negative number`);
+      }
+    }
+    const calculatedTotal = breakdown.inputCost + breakdown.outputCost + (breakdown.cacheCost || 0) + (breakdown.toolCosts || 0) + (breakdown.infrastructureCost || 0);
+    if (Number.isFinite(calculatedTotal) && Number.isFinite(cost.totalCost)) {
+      const difference = Math.abs(calculatedTotal - cost.totalCost);
+      const magnitude = Math.max(1, Math.abs(calculatedTotal), Math.abs(cost.totalCost));
+      const tolerance = Math.max(COST_TOLERANCE_ABSOLUTE, magnitude * COST_TOLERANCE_RELATIVE);
+      if (difference > tolerance) {
+        errors.push(
+          `costBreakdown sum (${calculatedTotal.toFixed(4)}) does not match totalCost (${cost.totalCost.toFixed(4)})`
+        );
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// src/telemetry/variant-normalization.ts
+function normalizeVariant(variant) {
+  if (typeof variant !== "string") {
+    return "unknown";
+  }
+  const trimmed = variant.trim();
+  return trimmed || "unknown";
+}
+function normalizeVariantForEventId(variant) {
+  const normalized = normalizeVariant(variant);
+  return normalized.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/-+/g, "-");
+}
+
+// src/telemetry/unified-telemetry.ts
+var ENV_NEW = "POETIC_UNIFIED_TELEMETRY";
+var ENV_LEGACY = "ENABLE_UNIFIED_TELEMETRY";
+var UNIFIED_TELEMETRY_FLAG = ENV_NEW;
+var legacyWarningEmitted = false;
+function buildModelInvocationEventId(taskId, variant, provider, model) {
+  const normalizedVariant = normalizeVariant(variant);
+  const canonicalVariant = canonicalizeVariantIdentifier({
+    variant: normalizedVariant,
+    provider,
+    model,
+    strategy: normalizedVariant.includes(":") ? void 0 : normalizedVariant,
+    executionMode: "local"
+  });
+  return `${taskId}-${normalizeVariantForEventId(canonicalVariant)}`;
+}
+function readUnifiedTelemetryFlag() {
+  const newVal = process.env[ENV_NEW];
+  const legacyVal = process.env[ENV_LEGACY];
+  if (newVal === void 0 && legacyVal !== void 0 && !legacyWarningEmitted) {
+    console.warn(`Warning: ${ENV_LEGACY} is deprecated; use ${ENV_NEW}.`);
+    legacyWarningEmitted = true;
+  }
+  return newVal ?? legacyVal;
+}
+var UnifiedTelemetryLogger = class _UnifiedTelemetryLogger {
+  telemetry;
+  costTracker;
+  telemetryDb;
+  // SQLite database connection (optional)
+  /** Track total dual-write operations for metrics */
+  dualWriteCount = 0;
+  /** Track dual-write errors for monitoring */
+  dualWriteErrors = 0;
+  /** Cache feature flag value (check once per instance) */
+  unifiedMode;
+  options;
+  /**
+   * Create a unified telemetry logger
+   *
+   * @param telemetry - Telemetry logger instance
+   * @param costTracker - Cost tracking instance
+   * @param telemetryDb - Optional SQLite database connection for data retrieval
+   */
+  constructor(telemetry, costTracker, telemetryDb, options = {}) {
+    this.telemetry = telemetry;
+    this.costTracker = costTracker;
+    this.telemetryDb = telemetryDb;
+    this.options = options;
+    this.unifiedMode = this.getFeatureFlag();
+    this.logInitialization();
+  }
+  /**
+   * Validates and converts a string to VariantLifecycleEvent
+   * @throws {Error} If event string is not a valid VariantLifecycleEvent
+   */
+  validateEventType(event) {
+    const validEvents = [
+      "started",
+      "first_commit",
+      "completed",
+      "failed",
+      "evaluated"
+    ];
+    if (!validEvents.includes(event)) {
+      throw new Error(
+        `Invalid variant event type: "${event}". Must be one of: ${validEvents.join(", ")}`
+      );
+    }
+    return event;
+  }
+  static formatUtcLogDate(date) {
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+    const day = String(date.getUTCDate()).padStart(2, "0");
+    return {
+      yearMonth: `${year}-${month}`,
+      day: `${year}-${month}-${day}`
+    };
+  }
+  /**
+   * Log a model invocation with cost data
+   *
+   * Core method for logging AI model invocations with associated cost information.
+   * Uses dual-write mode when unified telemetry is enabled.
+   *
+   * @param event - Event data with cost dimensions
+   * @returns Promise that resolves when logging is complete
+   *
+   * @throws {Error} If cost validation fails or logging errors occur
+   */
+  async logModelInvocation(event) {
+    if (event.cost) {
+      const validation = validateCostDimensions(event.cost);
+      if (!validation.valid) {
+        throw new Error(`Invalid cost dimensions: ${validation.errors.join(", ")}`);
+      }
+    }
+    const normalizedEvent = this.normalizeModelInvocationEvent(event);
+    if (this.unifiedMode) {
+      return this.dualWrite(normalizedEvent);
+    }
+    return this.legacyWrite(normalizedEvent);
+  }
+  /**
+   * Log a variant execution event with optional cost data
+   *
+   * Simplified method for logging variant-specific events. Cost data
+   * is optional and can be attached later.
+   *
+   * @param taskId - Task identifier
+   * @param variant - Variant name
+   * @param event - Event type
+   * @param data - Event data (may include cost)
+   */
+  async logVariantEvent(taskId, variant, event, data) {
+    const eventData = {
+      taskId,
+      variant: normalizeVariant(variant),
+      event,
+      provider: data?.provider || "unknown",
+      model: "unknown",
+      cost: data?.cost,
+      metadata: data
+    };
+    return this.logModelInvocation(eventData);
+  }
+  /**
+   * Validate consistency between telemetry and cost tracker
+   *
+   * Compares cost data between the two systems to ensure dual-write
+   * is working correctly. Should show 100% match when properly configured.
+   *
+   * @param options - Validation options
+   * @param options.startDate - Start of date range (ISO string)
+   * @param options.endDate - End of date range (ISO string)
+   * @param options.sampleSize - Maximum events to check (default: 1000)
+   * @returns Consistency report with match statistics
+   */
+  async validateConsistency(options) {
+    const sampleSize = options.sampleSize || 1e3;
+    await this.telemetry.flushAsync();
+    const telemetryEvents = await this.getTelemetryEventsWithCost(
+      options.startDate,
+      options.endDate,
+      sampleSize
+    );
+    const costTrackerEvents = await this.getCostTrackerEvents(
+      options.startDate,
+      options.endDate,
+      sampleSize
+    );
+    return this.compareEvents(telemetryEvents, costTrackerEvents);
+  }
+  /**
+   * Get dual-write statistics
+   *
+   * Returns metrics about dual-write operations for monitoring and debugging.
+   *
+   * @returns Statistics object
+   */
+  getDualWriteStats() {
+    const successRate = this.dualWriteCount > 0 ? 1 - this.dualWriteErrors / this.dualWriteCount : 1;
+    return {
+      enabled: this.unifiedMode,
+      totalWrites: this.dualWriteCount,
+      errors: this.dualWriteErrors,
+      successRate
+    };
+  }
+  /**
+   * Update feature flag at runtime (for testing)
+   *
+   * @param enabled - Whether to enable unified mode
+   */
+  setUnifiedMode(enabled) {
+    this.unifiedMode = enabled;
+    this.logModeChange();
+  }
+  // ============================================================================
+  // PRIVATE METHODS
+  // ============================================================================
+  normalizeModelInvocationEvent(event) {
+    return {
+      ...event,
+      variant: normalizeVariant(event.variant)
+    };
+  }
+  /**
+   * Dual-write to both telemetry and cost tracker
+   */
+  async dualWrite(event) {
+    this.dualWriteCount++;
+    const telemetryPromise = Promise.resolve().then(
+      () => this.telemetry.logVariantEvent(
+        event.taskId,
+        event.variant,
+        this.validateEventType(event.event),
+        {
+          provider: event.provider,
+          model: event.model,
+          strategy: event.variant,
+          executionMode: "local",
+          cost: event.cost,
+          cloudMetadata: {
+            costEstimate: event.cost?.totalCost,
+            ...event.metadata?.cloudMetadata
+          },
+          ...event.metadata
+        }
+      )
+    );
+    const costPromise = event.cost ? this.writeToCostTrackerWithRetry(event) : Promise.resolve();
+    const [telemetryResult, costResult] = await Promise.allSettled([telemetryPromise, costPromise]);
+    const telemetryOk = telemetryResult.status === "fulfilled";
+    const costTrackerOk = costResult.status === "fulfilled";
+    if (!telemetryOk) {
+      this.dualWriteErrors++;
+      this.logError("telemetry_write_failed", telemetryResult.reason);
+    }
+    if (!costTrackerOk && event.cost) {
+      this.dualWriteErrors++;
+      this.logError("cost_tracker_write_failed", costResult.reason);
+    }
+    if (!telemetryOk || !costTrackerOk && event.cost) {
+      try {
+        this.costTracker.logCostEvent("unified_telemetry_partial_failure", {
+          telemetryOk,
+          costTrackerOk,
+          event: event.event,
+          taskId: event.taskId,
+          timestamp: Date.now()
+        });
+      } catch (error) {
+        this.logError("partial_failure_logging_failed", error);
+      }
+    }
+    if (!telemetryOk && !costTrackerOk && event.cost) {
+      throw new Error(`Dual-write failed: telemetry=${telemetryOk}, costTracker=${costTrackerOk}`);
+    }
+    return { telemetry: telemetryOk, costTracker: event.cost ? costTrackerOk : false };
+  }
+  async writeToCostTrackerWithRetry(event) {
+    try {
+      await this.writeToCostTracker(event);
+    } catch (error) {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      await this.writeToCostTracker(event);
+      this.logError("cost_tracker_write_recovered_after_retry", error);
+    }
+  }
+  /**
+   * Legacy separate write mode
+   */
+  async legacyWrite(event) {
+    await this.telemetry.logVariantEvent(
+      event.taskId,
+      event.variant,
+      this.validateEventType(event.event),
+      {
+        provider: event.provider,
+        ...event.metadata
+      }
+    );
+    if (event.cost) {
+      await this.writeToCostTracker(event);
+    }
+    return { telemetry: true, costTracker: Boolean(event.cost) };
+  }
+  /**
+   * Write cost data to cost tracker
+   */
+  async writeToCostTracker(event) {
+    if (!event.cost) {
+      return;
+    }
+    this.costTracker.logCostEvent("model_invocation", {
+      taskId: event.taskId,
+      variant: event.variant,
+      provider: event.provider,
+      model: event.model,
+      inputTokens: event.cost.inputTokens ?? 0,
+      outputTokens: event.cost.outputTokens ?? 0,
+      totalCost: event.cost.totalCost,
+      currency: event.cost.currency,
+      timestamp: event.cost.timestamp,
+      cacheReadTokens: event.cost.cacheReadTokens ?? 0,
+      cacheWriteTokens: event.cost.cacheWriteTokens ?? 0,
+      cacheCost: event.cost.cacheCost ?? 0,
+      toolCosts: event.cost.toolCosts ?? 0,
+      infrastructureCost: event.cost.infrastructureCost ?? 0
+    });
+  }
+  /**
+   * Get telemetry events with cost data
+   *
+   * Queries the telemetry database (variant_executions) for events that have cost
+   * data embedded in their metadata. Cost is extracted from JSON-serialized cost
+   * dimensions in variant execution records.
+   *
+   * @param startDate - ISO date string for range start
+   * @param endDate - ISO date string for range end
+   * @param limit - Maximum number of events to return
+   * @returns Array of events with extracted cost data
+   */
+  async getTelemetryEventsWithCost(startDate, endDate, limit) {
+    if (!this.telemetryDb) {
+      return [];
+    }
+    try {
+      const startTimestamp = new Date(startDate).getTime();
+      const endTimestamp = new Date(endDate).getTime();
+      const startIso = new Date(startDate).toISOString();
+      const endIso = new Date(endDate).toISOString();
+      const scope = globalScope();
+      const query = `
+        SELECT
+          id,
+          task_id,
+          variant,
+          cloud_metadata,
+          created_at
+        FROM variant_executions
+        WHERE ${scope.where}
+          AND (
+          (typeof(created_at) = 'integer' AND created_at >= ? AND created_at <= ?)
+          OR (typeof(created_at) = 'text' AND created_at >= ? AND created_at <= ?)
+        )
+          AND cloud_metadata IS NOT NULL
+        ORDER BY created_at DESC
+        LIMIT ?
+      `;
+      const rows = this.telemetryDb.prepare(query).all(...scope.params, startTimestamp, endTimestamp, startIso, endIso, limit);
+      const events = [];
+      for (const row of rows) {
+        try {
+          const metadata = parseJsonWithContext(
+            row.cloud_metadata,
+            `[Unified Telemetry] cloud metadata for task ${row.task_id}`
+          );
+          if (typeof metadata.costEstimate === "number") {
+            events.push({
+              eventId: buildModelInvocationEventId(row.task_id, row.variant),
+              taskId: row.task_id,
+              cost: metadata.costEstimate
+            });
+          }
+        } catch (error) {
+          this.logError("metadata_parse_failed", error);
+          emitWarning(
+            "WS-003",
+            {
+              taskId: row.task_id,
+              subsystem: "telemetry",
+              variant: row.variant,
+              executionPhase: "validation"
+            },
+            {
+              severity: "WARN" /* WARN */,
+              metadata: {
+                operation: "metadata_parse",
+                error: error instanceof Error ? error.message : String(error),
+                eventId: `${row.task_id}-${row.variant}`
+              }
+            }
+          );
+        }
+      }
+      return events;
+    } catch (error) {
+      this.logError("telemetry_query_failed", error);
+      return [];
+    }
+  }
+  /**
+   * Get cost tracker events
+   *
+   * Reads cost events from the JSONL log files written by TelemetryCost.
+   * Scans log files within the date range and extracts model_invocation events
+   * with cost data.
+   *
+   * @param startDate - ISO date string for range start
+   * @param endDate - ISO date string for range end
+   * @param limit - Maximum number of events to return
+   * @returns Array of cost events from JSONL logs
+   */
+  async getCostTrackerEvents(startDate, endDate, limit) {
+    try {
+      const events = [];
+      const startDate_ = new Date(startDate);
+      const endDate_ = new Date(endDate);
+      const fs = await import("fs/promises");
+      const path = await import("path");
+      const logsDir = this.telemetry.getLogsDir();
+      try {
+        await fs.access(logsDir);
+      } catch {
+        return [];
+      }
+      const datesToScan = [];
+      const currentDate = new Date(startDate_);
+      while (currentDate <= endDate_) {
+        const { yearMonth, day } = _UnifiedTelemetryLogger.formatUtcLogDate(currentDate);
+        datesToScan.push(`${yearMonth}/${day}.jsonl`);
+        currentDate.setUTCDate(currentDate.getUTCDate() + 1);
+      }
+      for (const relPath of datesToScan) {
+        if (events.length >= limit) break;
+        const logPath = path.join(logsDir, relPath);
+        try {
+          const lineReader = createInterface({
+            input: createReadStream(logPath, { encoding: "utf8" }),
+            crlfDelay: Infinity
+          });
+          try {
+            for await (const line of lineReader) {
+              if (events.length >= limit) break;
+              if (!line.trim()) continue;
+              try {
+                const entry = parseJsonWithContext(
+                  line,
+                  `[Unified Telemetry] log entry from ${logPath}`
+                );
+                const totalCost = typeof entry.totalCost === "number" ? entry.totalCost : Number(entry.totalCost);
+                if (entry.event === "model_invocation" && entry.taskId && Number.isFinite(totalCost)) {
+                  const taskId = typeof entry.taskId === "string" ? entry.taskId : String(entry.taskId);
+                  const eventId = buildModelInvocationEventId(
+                    taskId,
+                    typeof entry.variant === "string" ? entry.variant : null,
+                    typeof entry.provider === "string" ? entry.provider : void 0,
+                    typeof entry.model === "string" ? entry.model : void 0
+                  );
+                  events.push({
+                    eventId,
+                    taskId,
+                    cost: totalCost
+                  });
+                }
+              } catch (error) {
+                this.logError("jsonl_line_parse_failed", error);
+                emitWarning(
+                  "WS-003",
+                  {
+                    taskId: "unknown",
+                    subsystem: "telemetry",
+                    executionPhase: "validation"
+                  },
+                  {
+                    severity: "WARN" /* WARN */,
+                    metadata: {
+                      operation: "jsonl_parse_line",
+                      error: error instanceof Error ? error.message : String(error),
+                      file: relPath,
+                      linePreview: line.substring(0, 100)
+                    }
+                  }
+                );
+              }
+            }
+          } finally {
+            lineReader.close();
+          }
+        } catch (error) {
+          this.logError("jsonl_file_read_failed", error);
+          emitWarning(
+            "WS-003",
+            {
+              taskId: "unknown",
+              subsystem: "telemetry",
+              executionPhase: "validation"
+            },
+            {
+              severity: "WARN" /* WARN */,
+              metadata: {
+                operation: "jsonl_file_read",
+                error: error instanceof Error ? error.message : String(error),
+                file: relPath
+              }
+            }
+          );
+        }
+      }
+      return events;
+    } catch (error) {
+      this.logError("cost_tracker_query_failed", error);
+      return [];
+    }
+  }
+  /**
+   * Compare events from both systems
+   */
+  compareEvents(telemetryEvents, costTrackerEvents) {
+    const groupCosts = (events) => {
+      const grouped = /* @__PURE__ */ new Map();
+      for (const event of events) {
+        const bucket = grouped.get(event.eventId) ?? [];
+        bucket.push(event.cost);
+        grouped.set(event.eventId, bucket);
+      }
+      return grouped;
+    };
+    const telemetryMap = groupCosts(telemetryEvents);
+    const costTrackerMap = groupCosts(costTrackerEvents);
+    const discrepancyDetails = [];
+    let matchingEvents = 0;
+    for (const [eventId, telemetryCosts] of telemetryMap) {
+      const costTrackerCosts = costTrackerMap.get(eventId) ?? [];
+      const comparisons = Math.max(telemetryCosts.length, costTrackerCosts.length);
+      for (let index = 0; index < comparisons; index += 1) {
+        const telemetryCost = telemetryCosts[index];
+        const costTrackerCost = costTrackerCosts[index];
+        if (telemetryCost === void 0) {
+          discrepancyDetails.push({
+            eventId,
+            telemetryCost: 0,
+            costTrackerCost: costTrackerCost ?? 0,
+            difference: costTrackerCost ?? 0
+          });
+        } else if (costTrackerCost === void 0) {
+          discrepancyDetails.push({
+            eventId,
+            telemetryCost,
+            costTrackerCost: 0,
+            difference: telemetryCost
+          });
+        } else if (Math.abs(telemetryCost - costTrackerCost) > 1e-4) {
+          discrepancyDetails.push({
+            eventId,
+            telemetryCost,
+            costTrackerCost,
+            difference: Math.abs(telemetryCost - costTrackerCost)
+          });
+        } else {
+          matchingEvents++;
+        }
+      }
+    }
+    for (const [eventId, costTrackerCosts] of costTrackerMap) {
+      if (telemetryMap.has(eventId)) {
+        continue;
+      }
+      for (const costTrackerCost of costTrackerCosts) {
+        discrepancyDetails.push({
+          eventId,
+          telemetryCost: 0,
+          costTrackerCost,
+          difference: costTrackerCost
+        });
+      }
+    }
+    const totalEvents = Math.max(telemetryEvents.length, costTrackerEvents.length);
+    const matchPercentage = totalEvents > 0 ? matchingEvents / totalEvents * 100 : 100;
+    return {
+      totalEvents,
+      matchingEvents,
+      discrepancies: discrepancyDetails.length,
+      matchPercentage,
+      discrepancyDetails,
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Get feature flag value using the centralized env reader.
+   */
+  getFeatureFlag() {
+    const value = readUnifiedTelemetryFlag();
+    if (value === void 0) {
+      return this.options.defaultUnifiedMode ?? false;
+    }
+    switch (value.trim().toLowerCase()) {
+      case "1":
+      case "true":
+      case "yes":
+      case "on":
+        return true;
+      default:
+        return false;
+    }
+  }
+  /**
+   * Log initialization
+   */
+  logInitialization() {
+    this.costTracker.logCostEvent("unified_telemetry_initialized", {
+      mode: this.unifiedMode ? "dual-write" : "legacy",
+      flag: UNIFIED_TELEMETRY_FLAG,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Log mode change
+   */
+  logModeChange() {
+    this.costTracker.logCostEvent("unified_telemetry_mode_changed", {
+      mode: this.unifiedMode ? "dual-write" : "legacy",
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Log error
+   */
+  logError(errorType, error) {
+    this.costTracker.logCostEvent("unified_telemetry_error", {
+      errorType,
+      error: error instanceof Error ? error.message : String(error),
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Reconcile inconsistencies between telemetry and cost tracker.
+   *
+   */
+  async reconcileInconsistencies(options) {
+    const report = await this.validateConsistency(options);
+    if (report.matchPercentage < 95) {
+      this.costTracker.logCostEvent("unified_telemetry_consistency_alert", {
+        matchPercentage: report.matchPercentage,
+        discrepancies: report.discrepancies,
+        threshold: 95,
+        timestamp: Date.now()
+      });
+    }
+    const fixed = 0;
+    const errors = 0;
+    if (options.autoFix) {
+    }
+    return {
+      inconsistencies: report.discrepancies,
+      fixed,
+      errors
+    };
+  }
+};
+function createUnifiedTelemetryLogger(telemetry, costTracker, telemetryDb, options) {
+  return new UnifiedTelemetryLogger(telemetry, costTracker, telemetryDb, options);
+}
+
+// src/telemetry/unified-cost-tracker.ts
+var COST_BUCKET_MS = 60 * 60 * 1e3;
+var UNIFIED_COST_METRIC_SOURCE_SAMPLES = /* @__PURE__ */ Symbol(
+  "poetic.unifiedCostMetricSourceSamples"
+);
+var UnifiedCostTracker = class {
+  config;
+  costCalculator;
+  telemetry;
+  unifiedLogger;
+  sessionStart = Date.now();
+  samples = [];
+  pricingReady = false;
+  droppedSamplesCost = 0;
+  droppedCostBuckets = /* @__PURE__ */ new Map();
+  constructor(costCalculator, telemetry, config) {
+    this.costCalculator = costCalculator;
+    this.telemetry = telemetry;
+    this.config = {
+      enabled: config?.enabled ?? true,
+      budgetThresholds: {
+        warning: 10,
+        critical: 50,
+        daily: 100,
+        monthly: 1e3,
+        ...config?.budgetThresholds
+      },
+      ...config?.optimization !== void 0 ? { optimization: config.optimization } : {},
+      ...config?.updateIntervalMs !== void 0 ? { updateIntervalMs: config.updateIntervalMs } : {}
+    };
+    this.unifiedLogger = (() => {
+      try {
+        return createUnifiedTelemetryLogger(telemetry, telemetry.costModule, void 0, {
+          defaultUnifiedMode: true
+        });
+      } catch {
+        return null;
+      }
+    })();
+    this.ensurePricingLoaded();
+  }
+  ensurePricingLoaded() {
+    if (this.pricingReady) return;
+    try {
+      this.costCalculator.ensurePricingLoadedSync();
+      this.pricingReady = true;
+    } catch (error) {
+      this.telemetry.logCostEvent("pricing_load_error", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  trackCost(provider, model, usage, executionId, taskId, competitionId, variantId) {
+    this.ensurePricingLoaded();
+    if (!this.pricingReady) {
+      throw new Error("Pricing data not loaded. Call loadPricingData() first.");
+    }
+    const breakdown = this.costCalculator.calculateCost(provider, model, usage);
+    if (!this.config.enabled) {
+      return breakdown;
+    }
+    if (breakdown.pricingStatus === "unavailable" || breakdown.totalCostAmount.status !== "available") {
+      this.telemetry.logCostEvent("cost_pricing_unavailable", {
+        provider,
+        model,
+        executionId,
+        taskId,
+        competitionId,
+        variantId,
+        originalModelId: breakdown.originalModelId,
+        canonicalModelId: breakdown.canonicalModelId,
+        pricingSource: breakdown.pricingSource,
+        pricingConfidence: breakdown.pricingConfidence,
+        pricingError: breakdown.pricingError ?? (breakdown.totalCostAmount.status !== "available" ? breakdown.totalCostAmount.detail : void 0),
+        costStatus: breakdown.totalCostAmount.status
+      });
+      return breakdown;
+    }
+    const availableTotal = breakdown.totalCostAmount.amount;
+    const timestamp = Date.now();
+    this.samples.push({
+      timestamp,
+      provider,
+      model,
+      totalCost: availableTotal,
+      ...executionId ? { executionId } : {}
+    });
+    if (this.samples.length > 200) {
+      const dropped = this.samples.splice(0, this.samples.length - 200);
+      this.droppedSamplesCost += dropped.reduce((s, x) => s + x.totalCost, 0);
+      for (const sample of dropped) {
+        const bucket = Math.floor(sample.timestamp / COST_BUCKET_MS) * COST_BUCKET_MS;
+        this.droppedCostBuckets.set(
+          bucket,
+          (this.droppedCostBuckets.get(bucket) ?? 0) + sample.totalCost
+        );
+      }
+    }
+    this.telemetry.logCostEvent("cost_tracked", {
+      provider,
+      model,
+      totalCost: availableTotal,
+      executionId,
+      taskId,
+      competitionId,
+      variantId,
+      billingMode: breakdown.billingMode,
+      billingSource: breakdown.billingSource,
+      originalModelId: breakdown.originalModelId,
+      canonicalModelId: breakdown.canonicalModelId,
+      pricingSource: breakdown.pricingSource,
+      pricingConfidence: breakdown.pricingConfidence,
+      pricingStatus: breakdown.pricingStatus ?? "ok",
+      pricingVersion: breakdown.pricingVersion
+    });
+    if (this.unifiedLogger) {
+      void this.unifiedLogger.logModelInvocation({
+        taskId: taskId || executionId || competitionId || "unknown",
+        provider,
+        model,
+        variant: variantId,
+        event: "completed",
+        cost: {
+          provider,
+          model,
+          inputTokens: usage.inputTokens ?? 0,
+          outputTokens: usage.outputTokens ?? 0,
+          cacheReadTokens: usage.cacheReadTokens ?? 0,
+          cacheWriteTokens: usage.cacheWriteTokens ?? 0,
+          totalCost: availableTotal,
+          currency: breakdown.currency,
+          timestamp,
+          billingMode: breakdown.billingMode === "metered" ? "metered" : "subscription",
+          pricingVersion: breakdown.pricingVersion,
+          costBreakdown: {
+            inputCost: breakdown.inputCost,
+            outputCost: breakdown.outputCost,
+            cacheCost: breakdown.cacheCost,
+            toolCosts: breakdown.toolCosts,
+            infrastructureCost: breakdown.infrastructureCost
+          }
+        }
+      }).catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(
+          `[UnifiedCostTracker] Failed to mirror cost event to unified telemetry: ${message}`
+        );
+      });
+    }
+    return breakdown;
+  }
+  getCurrentMetrics() {
+    const now = Date.now();
+    const dayWindow = now - 24 * 60 * 60 * 1e3;
+    const monthWindow = now - 30 * 24 * 60 * 60 * 1e3;
+    this.pruneDroppedCostBuckets(monthWindow);
+    const sessionCost = this.droppedSamplesCost + this.samples.reduce((sum, item) => sum + item.totalCost, 0);
+    const dailyCost = this.getDroppedCostSince(dayWindow) + this.samples.filter((item) => item.timestamp >= dayWindow).reduce((sum, item) => sum + item.totalCost, 0);
+    const monthlyCost = this.getDroppedCostSince(monthWindow) + this.samples.filter((item) => item.timestamp >= monthWindow).reduce((sum, item) => sum + item.totalCost, 0);
+    const minutesElapsed = Math.max((now - this.sessionStart) / 6e4, 1 / 60);
+    const costPerMinute = sessionCost / minutesElapsed;
+    const byProviderModel = /* @__PURE__ */ new Map();
+    for (const sample of this.samples) {
+      const key = `${sample.provider}::${sample.model}`;
+      const current = byProviderModel.get(key);
+      if (current) {
+        current.total += sample.totalCost;
+      } else {
+        byProviderModel.set(key, {
+          provider: sample.provider,
+          model: sample.model,
+          total: sample.totalCost
+        });
+      }
+    }
+    let top = {
+      provider: "none",
+      model: "none",
+      total: 0
+    };
+    for (const entry of byProviderModel.values()) {
+      if (entry.total > top.total) {
+        top = entry;
+      }
+    }
+    const activeAlerts = [];
+    if (dailyCost >= this.config.budgetThresholds.critical) {
+      activeAlerts.push({
+        id: "daily-critical",
+        type: "budget_critical",
+        severity: "critical",
+        message: `Daily cost exceeded critical threshold (${this.config.budgetThresholds.critical.toFixed(2)} USD)`,
+        currentCost: dailyCost,
+        threshold: this.config.budgetThresholds.critical,
+        timestamp: now,
+        metadata: { period: "daily" }
+      });
+    } else if (dailyCost >= this.config.budgetThresholds.warning) {
+      activeAlerts.push({
+        id: "daily-warning",
+        type: "budget_warning",
+        severity: "high",
+        message: `Daily cost exceeded warning threshold (${this.config.budgetThresholds.warning.toFixed(2)} USD)`,
+        currentCost: dailyCost,
+        threshold: this.config.budgetThresholds.warning,
+        timestamp: now,
+        metadata: { period: "daily" }
+      });
+    }
+    if (monthlyCost >= this.config.budgetThresholds.monthly) {
+      activeAlerts.push({
+        id: "monthly-critical",
+        type: "budget_critical",
+        severity: "critical",
+        message: `Monthly cost exceeded threshold (${this.config.budgetThresholds.monthly.toFixed(2)} USD)`,
+        currentCost: monthlyCost,
+        threshold: this.config.budgetThresholds.monthly,
+        timestamp: now,
+        metadata: { period: "monthly" }
+      });
+    }
+    const trend = this.samples.slice(-10).map((item) => item.totalCost);
+    const metrics = {
+      sessionCost,
+      dailyCost,
+      monthlyCost,
+      costPerMinute,
+      topCostProvider: {
+        provider: top.provider,
+        model: top.model,
+        cost: top.total,
+        percentage: sessionCost > 0 ? top.total / sessionCost * 100 : 0
+      },
+      costTrend: trend,
+      activeAlerts,
+      availableOptimizations: []
+    };
+    Object.defineProperty(metrics, UNIFIED_COST_METRIC_SOURCE_SAMPLES, {
+      value: this.samples.slice(),
+      enumerable: false,
+      configurable: false,
+      writable: false
+    });
+    return metrics;
+  }
+  getDroppedCostSince(cutoffMs) {
+    let total = 0;
+    for (const [bucket, cost] of this.droppedCostBuckets.entries()) {
+      if (bucket + COST_BUCKET_MS > cutoffMs) {
+        total += cost;
+      }
+    }
+    return total;
+  }
+  pruneDroppedCostBuckets(cutoffMs) {
+    for (const bucket of this.droppedCostBuckets.keys()) {
+      if (bucket + COST_BUCKET_MS <= cutoffMs) {
+        this.droppedCostBuckets.delete(bucket);
+      }
+    }
+  }
+};
+var globalCostTracker = null;
+function getUnifiedCostTracker(costCalculator, logger, config) {
+  if (!globalCostTracker) {
+    if (!costCalculator || !logger) {
+      throw new Error(
+        "UnifiedCostTracker not initialized. Provide costCalculator and logger on first call."
+      );
+    }
+    globalCostTracker = new UnifiedCostTracker(costCalculator, logger, config);
+  }
+  return globalCostTracker;
+}
+
+export {
+  normalizeVariant,
+  normalizeVariantForEventId,
+  UNIFIED_COST_METRIC_SOURCE_SAMPLES,
+  UnifiedCostTracker,
+  getUnifiedCostTracker
+};
+//# sourceMappingURL=chunk-FCNAS3W2.js.map