@cesteral/dbm-mcp 1.0.0

package/dist/mcp-server/transports/streamable-http-transport.d.ts

@@ -0,0 +1,55 @@
+import type { Logger } from "pino";
+export declare const createMcpHttpServer: (config: {
+    serviceName: string;
+    port: number;
+    otelServiceName: string;
+    mcpAuthMode: "google-headers" | "jwt" | "none";
+    rateLimitPerMinute: number;
+    reportCacheTtlMs: number;
+    reportPollMaxRetries: number;
+    reportPollInitialDelayMs: number;
+    reportPollMaxDelayMs: number;
+    reportQueryRetries: number;
+    reportRetryCooldownMs: number;
+    host: string;
+    nodeEnv: "development" | "production" | "test";
+    mcpStatefulSessionTimeoutMs: number;
+    logLevel: "debug" | "info" | "notice" | "warning" | "error";
+    mcpLogLevel: "debug" | "info" | "notice" | "warning" | "error";
+    otelEnabled: boolean;
+    gcpProjectId?: string | undefined;
+    serviceAccountJson?: string | undefined;
+    serviceAccountFile?: string | undefined;
+    mcpAuthSecretKey?: string | undefined;
+    mcpAllowedOrigins?: string | undefined;
+    otelExporterOtlpTracesEndpoint?: string | undefined;
+    otelExporterOtlpMetricsEndpoint?: string | undefined;
+    gcsBucketName?: string | undefined;
+}, logger: Logger) => ReturnType<typeof import("@cesteral/shared").createMcpHttpTransport>, startHttpServer: (config: {
+    serviceName: string;
+    port: number;
+    otelServiceName: string;
+    mcpAuthMode: "google-headers" | "jwt" | "none";
+    rateLimitPerMinute: number;
+    reportCacheTtlMs: number;
+    reportPollMaxRetries: number;
+    reportPollInitialDelayMs: number;
+    reportPollMaxDelayMs: number;
+    reportQueryRetries: number;
+    reportRetryCooldownMs: number;
+    host: string;
+    nodeEnv: "development" | "production" | "test";
+    mcpStatefulSessionTimeoutMs: number;
+    logLevel: "debug" | "info" | "notice" | "warning" | "error";
+    mcpLogLevel: "debug" | "info" | "notice" | "warning" | "error";
+    otelEnabled: boolean;
+    gcpProjectId?: string | undefined;
+    serviceAccountJson?: string | undefined;
+    serviceAccountFile?: string | undefined;
+    mcpAuthSecretKey?: string | undefined;
+    mcpAllowedOrigins?: string | undefined;
+    otelExporterOtlpTracesEndpoint?: string | undefined;
+    otelExporterOtlpMetricsEndpoint?: string | undefined;
+    gcsBucketName?: string | undefined;
+}, logger: Logger) => Promise<import("@cesteral/shared").McpHttpServer>;
+//# sourceMappingURL=streamable-http-transport.d.ts.map

package/dist/mcp-server/transports/streamable-http-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streamable-http-transport.d.ts","sourceRoot":"","sources":["../../../src/mcp-server/transports/streamable-http-transport.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAmEnC,eAAO,MAAQ,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;4FAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;uEACS,CAAC"}

package/dist/mcp-server/transports/streamable-http-transport.js

@@ -0,0 +1,55 @@
+import { createMcpServer } from "../server.js";
+import { createAuthStrategy, buildServerCardExtras, createTransportEntrypoints, } from "@cesteral/shared";
+import { createSessionServices, sessionServiceStore } from "../../services/session-services.js";
+import { rateLimiter } from "../../utils/platform.js";
+function buildPlatformConfig(config, logger) {
+    return {
+        authStrategy: createAuthStrategy(config.mcpAuthMode, {
+            scopes: ["https://www.googleapis.com/auth/doubleclickbidmanager"],
+            jwtSecret: config.mcpAuthSecretKey,
+            logger,
+        }),
+        corsAllowHeaders: [
+            "Content-Type",
+            "Authorization",
+            "Mcp-Session-Id",
+            "MCP-Protocol-Version",
+            "X-Google-Auth-Type",
+            "X-Google-Credentials",
+            "X-Google-Client-Id",
+            "X-Google-Client-Secret",
+            "X-Google-Refresh-Token",
+        ],
+        authErrorHint: config.mcpAuthMode === "google-headers"
+            ? "Provide Google credentials via X-Google-Auth-Type and associated headers."
+            : "Provide a valid Bearer token in the Authorization header.",
+        sessionServiceStore,
+        rateLimiter,
+        async createSessionForAuth(authResult, sessionId, appConfig, log) {
+            const adapter = authResult.googleAuthAdapter;
+            if (adapter) {
+                await adapter.validate();
+                const services = createSessionServices(adapter, appConfig, log, rateLimiter);
+                sessionServiceStore.set(sessionId, services, authResult.credentialFingerprint);
+                return { services };
+            }
+            if (appConfig.mcpAuthMode !== "none") {
+                return {
+                    services: null,
+                    error: {
+                        message: "Google API credentials required for this server. Use MCP_AUTH_MODE=google-headers.",
+                        status: 400,
+                    },
+                };
+            }
+            return { services: null };
+        },
+        async createMcpServer(log, sessionId, gcsBucket) {
+            return createMcpServer(log, sessionId, gcsBucket);
+        },
+        packageJsonPath: new URL("../../../package.json", import.meta.url).pathname,
+        serverCard: buildServerCardExtras("dbm-mcp"),
+    };
+}
+export const { createMcpHttpServer, startHttpServer } = createTransportEntrypoints(buildPlatformConfig);
+//# sourceMappingURL=streamable-http-transport.js.map

package/dist/mcp-server/transports/streamable-http-transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"streamable-http-transport.js","sourceRoot":"","sources":["../../../src/mcp-server/transports/streamable-http-transport.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EACL,kBAAkB,EAIlB,qBAAqB,EACrB,0BAA0B,GAC3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAChG,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEtD,SAAS,mBAAmB,CAAC,MAAiB,EAAE,MAAc;IAC5D,OAAO;QACL,YAAY,EAAE,kBAAkB,CAAC,MAAM,CAAC,WAAuB,EAAE;YAC/D,MAAM,EAAE,CAAC,uDAAuD,CAAC;YACjE,SAAS,EAAE,MAAM,CAAC,gBAAgB;YAClC,MAAM;SACP,CAAC;QACF,gBAAgB,EAAE;YAChB,cAAc;YACd,eAAe;YACf,gBAAgB;YAChB,sBAAsB;YACtB,oBAAoB;YACpB,sBAAsB;YACtB,oBAAoB;YACpB,wBAAwB;YACxB,wBAAwB;SACzB;QACD,aAAa,EACX,MAAM,CAAC,WAAW,KAAK,gBAAgB;YACrC,CAAC,CAAC,2EAA2E;YAC7E,CAAC,CAAC,2DAA2D;QACjE,mBAAmB;QACnB,WAAW;QACX,KAAK,CAAC,oBAAoB,CAAC,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG;YAC9D,MAAM,OAAO,GAAG,UAAU,CAAC,iBAAkD,CAAC;YAC9E,IAAI,OAAO,EAAE,CAAC;gBACZ,MAAM,OAAO,CAAC,QAAQ,EAAE,CAAC;gBACzB,MAAM,QAAQ,GAAG,qBAAqB,CAAC,OAAO,EAAE,SAAsB,EAAE,GAAG,EAAE,WAAW,CAAC,CAAC;gBAC1F,mBAAmB,CAAC,GAAG,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,CAAC,qBAAqB,CAAC,CAAC;gBAC/E,OAAO,EAAE,QAAQ,EAAE,CAAC;YACtB,CAAC;YACD,IAAI,SAAS,CAAC,WAAW,KAAK,MAAM,EAAE,CAAC;gBACrC,OAAO;oBACL,QAAQ,EAAE,IAAI;oBACd,KAAK,EAAE;wBACL,OAAO,EACL,oFAAoF;wBACtF,MAAM,EAAE,GAAG;qBACZ;iBACF,CAAC;YACJ,CAAC;YAED,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;QAC5B,CAAC;QACD,KAAK,CAAC,eAAe,CAAC,GAAG,EAAE,SAAS,EAAE,SAAS;YAC7C,OAAO,eAAe,CAAC,GAAG,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;QACpD,CAAC;QACD,eAAe,EAAE,IAAI,GAAG,CAAC,uBAAuB,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,QAAQ;QAC3E,UAAU,EAAE,qBAAqB,CAAC,SAAS,CAAC;KAC7C,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,EAAE,mBAAmB,EAAE,eAAe,EAAE,GACnD,0BAA0B,CAAY,mBAAmB,CAAC,CAAC"}

package/dist/services/bid-manager/BidManagerService.d.ts

@@ -0,0 +1,68 @@
+import type { Logger } from "pino";
+import type { AppConfig } from "../../config/index.js";
+import type { BidManagerClient } from "./client.js";
+import { type RateLimiter } from "@cesteral/shared";
+import { calculatePerformanceMetrics } from "./report-parser.js";
+import type { DeliveryMetrics, HistoricalDataPoint, PacingStatus, GetDeliveryMetricsInput, GetHistoricalMetricsInput, GetPacingStatusInput, QuerySpec, ReportMetadata, ExponentialBackoffConfig } from "./types.js";
+export declare class BidManagerService {
+    private config;
+    private logger;
+    private client;
+    private rateLimiter?;
+    constructor(config: AppConfig, logger: Logger, client: BidManagerClient, rateLimiter?: RateLimiter | undefined);
+    createQuery(spec: QuerySpec): Promise<{
+        queryId: string;
+    }>;
+    runQuery(queryId: string): Promise<{
+        reportId: string;
+    }>;
+    getReportStatus(queryId: string, reportId: string): Promise<ReportMetadata>;
+    pollForCompletion(queryId: string, reportId: string, options?: Partial<ExponentialBackoffConfig>): Promise<ReportMetadata>;
+    continueQuery(queryId: string, reportId?: string): Promise<{
+        reportId: string;
+        isNewRun: boolean;
+    }>;
+    executeQueryWithRetry(spec: QuerySpec, options?: {
+        maxRetries?: number;
+        retryCooldownMs?: number;
+        backoffConfig?: Partial<ExponentialBackoffConfig>;
+    }): Promise<{
+        gcsPath: string;
+        queryId: string;
+        reportId: string;
+    }>;
+    private executeQueryWithRetryInner;
+    fetchReportData(gcsPath: string): Promise<string>;
+    private fetchReportDataInner;
+    getDeliveryMetrics(params: GetDeliveryMetricsInput): Promise<DeliveryMetrics>;
+    private getDeliveryMetricsInner;
+    getHistoricalMetrics(params: GetHistoricalMetricsInput): Promise<HistoricalDataPoint[]>;
+    private getHistoricalMetricsInner;
+    getPacingStatus(params: GetPacingStatusInput): Promise<PacingStatus>;
+    private getPacingStatusInner;
+    getPerformanceMetrics(params: GetDeliveryMetricsInput): Promise<ReturnType<typeof calculatePerformanceMetrics>>;
+    executeCustomQuery(params_: {
+        reportType: string;
+        groupBys: string[];
+        metrics: string[];
+        filters?: Array<{
+            type: string;
+            value: string;
+        }>;
+        dateRange: {
+            preset?: string;
+            startDate?: string;
+            endDate?: string;
+        };
+        outputFormat?: "structured" | "csv";
+    }): Promise<{
+        queryId: string;
+        reportId: string;
+        status: string;
+        rowCount: number;
+        columns: string[];
+        data: Record<string, unknown>[] | string;
+    }>;
+    private executeCustomQueryInner;
+}
+//# sourceMappingURL=BidManagerService.d.ts.map

package/dist/services/bid-manager/BidManagerService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BidManagerService.d.ts","sourceRoot":"","sources":["../../../src/services/bid-manager/BidManagerService.ts"],"names":[],"mappings":"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"}

package/dist/services/bid-manager/BidManagerService.js

@@ -0,0 +1,464 @@
+import { csvToJson } from "./report-parser.js";
+import { delay, pollUntilComplete, ReportTimeoutError, ReportFailedError, mapReportingError, } from "@cesteral/shared";
+import { QueryCreationError, QueryExecutionError, ReportGenerationError, ReportFetchError, BidManagerError, RetryExhaustedError, } from "../../utils/errors/bid-manager-errors.js";
+import { parseCSVToDeliveryMetrics, parseCSVToHistoricalData, calculatePerformanceMetrics, } from "./report-parser.js";
+import { safeDivide, round } from "../../utils/math.js";
+import { daysBetween } from "../../utils/date.js";
+import { withBidManagerApiSpan } from "../../utils/platform.js";
+function parseDateString(dateStr) {
+    const [year, month, day] = dateStr.split("-").map(Number);
+    return { year, month, day };
+}
+function getTodayString() {
+    const today = new Date();
+    return today.toISOString().split("T")[0];
+}
+export class BidManagerService {
+    config;
+    logger;
+    client;
+    rateLimiter;
+    constructor(config, logger, client, rateLimiter) {
+        this.config = config;
+        this.logger = logger;
+        this.client = client;
+        this.rateLimiter = rateLimiter;
+    }
+    async createQuery(spec) {
+        this.logger.info({ title: spec.metadata.title }, "Creating Bid Manager query");
+        try {
+            await this.rateLimiter?.consume("bidmanager:global");
+            const response = await this.client.queries.create({
+                requestBody: {
+                    metadata: {
+                        title: spec.metadata.title,
+                        dataRange: {
+                            range: spec.metadata.dataRange.range,
+                            customStartDate: spec.metadata.dataRange.customStartDate,
+                            customEndDate: spec.metadata.dataRange.customEndDate,
+                        },
+                        format: spec.metadata.format || "CSV",
+                    },
+                    params: {
+                        type: spec.params.type,
+                        groupBys: spec.params.groupBys,
+                        metrics: spec.params.metrics,
+                        filters: spec.params.filters?.map((f) => ({
+                            type: f.type,
+                            value: f.value,
+                        })),
+                    },
+                },
+            });
+            const queryId = response.data.queryId;
+            if (!queryId) {
+                throw new QueryCreationError("No queryId returned from API");
+            }
+            this.logger.info({ queryId }, "Query created successfully");
+            return { queryId };
+        }
+        catch (error) {
+            if (error instanceof QueryCreationError) {
+                throw error;
+            }
+            this.logger.error({ error }, "Failed to create query");
+            throw new QueryCreationError(error instanceof Error ? error.message : String(error), error);
+        }
+    }
+    async runQuery(queryId) {
+        this.logger.info({ queryId }, "Running Bid Manager query");
+        try {
+            await this.rateLimiter?.consume("bidmanager:global");
+            const response = await this.client.queries.run({ queryId });
+            const reportId = response.data.key?.reportId;
+            if (!reportId) {
+                throw new QueryExecutionError(queryId, "No reportId returned from API");
+            }
+            this.logger.info({ queryId, reportId }, "Query execution started");
+            return { reportId };
+        }
+        catch (error) {
+            if (error instanceof QueryExecutionError) {
+                throw error;
+            }
+            this.logger.error({ error, queryId }, "Failed to run query");
+            throw new QueryExecutionError(queryId, error instanceof Error ? error.message : String(error), error);
+        }
+    }
+    async getReportStatus(queryId, reportId) {
+        try {
+            await this.rateLimiter?.consume("bidmanager:global");
+            const response = await this.client.queries.reports.get({ queryId, reportId });
+            return {
+                status: {
+                    state: response.data.metadata?.status?.state || "QUEUED",
+                    format: response.data.metadata?.status?.format ?? undefined,
+                },
+                googleCloudStoragePath: response.data.metadata?.googleCloudStoragePath ?? undefined,
+            };
+        }
+        catch (error) {
+            this.logger.error({ error, queryId, reportId }, "Failed to get report status");
+            throw mapReportingError(error, "dbm");
+        }
+    }
+    async pollForCompletion(queryId, reportId, options) {
+        const config = {
+            initialDelayMs: options?.initialDelayMs ?? this.config.reportPollInitialDelayMs ?? 2000,
+            maxDelayMs: options?.maxDelayMs ?? this.config.reportPollMaxDelayMs ?? 60000,
+            maxRetries: options?.maxRetries ?? this.config.reportPollMaxRetries ?? 10,
+            backoffMultiplier: options?.backoffMultiplier ?? 2,
+        };
+        this.logger.info({ queryId, reportId, config }, "Starting exponential backoff polling");
+        await delay(config.initialDelayMs);
+        try {
+            return await pollUntilComplete({
+                fetchStatus: () => this.getReportStatus(queryId, reportId),
+                isComplete: (r) => r.status.state === "DONE",
+                isFailed: (r) => r.status.state === "FAILED",
+                initialDelayMs: config.initialDelayMs,
+                maxDelayMs: config.maxDelayMs,
+                maxAttempts: config.maxRetries,
+                backoffFactor: config.backoffMultiplier,
+            });
+        }
+        catch (error) {
+            if (error instanceof ReportFailedError) {
+                const failed = error.status;
+                throw new ReportGenerationError(queryId, reportId, failed.status.format);
+            }
+            throw error;
+        }
+    }
+    async continueQuery(queryId, reportId) {
+        this.logger.info({ queryId, existingReportId: reportId }, "Attempting to continue query");
+        if (reportId) {
+            try {
+                const report = await this.getReportStatus(queryId, reportId);
+                const state = report.status.state;
+                if (state === "DONE" || state === "RUNNING" || state === "QUEUED") {
+                    this.logger.info({ queryId, reportId, status: state }, "Existing report still valid");
+                    return { reportId, isNewRun: false };
+                }
+                this.logger.info({ queryId, reportId, status: state }, "Existing report not usable, will re-run query");
+            }
+            catch (error) {
+                this.logger.warn({ error: error instanceof Error ? error.message : String(error), queryId, reportId }, "Could not get existing report status, will re-run query");
+            }
+        }
+        const result = await this.runQuery(queryId);
+        return { reportId: result.reportId, isNewRun: true };
+    }
+    async executeQueryWithRetry(spec, options) {
+        return withBidManagerApiSpan("executeQueryWithRetry", undefined, async () => {
+            return this.executeQueryWithRetryInner(spec, options);
+        });
+    }
+    async executeQueryWithRetryInner(spec, options) {
+        const maxRetries = options?.maxRetries ?? this.config.reportQueryRetries ?? 3;
+        const retryCooldownMs = options?.retryCooldownMs ?? this.config.reportRetryCooldownMs ?? 60000;
+        let queryId;
+        let reportId;
+        let lastError;
+        let lastStatus;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                this.logger.info({
+                    attempt: attempt + 1,
+                    maxRetries,
+                    existingQueryId: queryId,
+                    existingReportId: reportId,
+                }, "Query execution attempt");
+                if (!queryId) {
+                    const createResult = await this.createQuery(spec);
+                    queryId = createResult.queryId;
+                }
+                const continueResult = await this.continueQuery(queryId, reportId);
+                reportId = continueResult.reportId;
+                if (continueResult.isNewRun) {
+                    this.logger.debug({ queryId, reportId }, "Started new query run");
+                }
+                else {
+                    this.logger.debug({ queryId, reportId }, "Continuing existing query run");
+                }
+                const report = await this.pollForCompletion(queryId, reportId, options?.backoffConfig);
+                lastStatus = report.status.state;
+                if (!report.googleCloudStoragePath) {
+                    throw new ReportFetchError("No GCS path in completed report", undefined);
+                }
+                this.logger.info({ queryId, reportId, attempts: attempt + 1 }, "Query executed successfully");
+                return { gcsPath: report.googleCloudStoragePath, queryId, reportId };
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                if (error instanceof ReportTimeoutError) {
+                    lastStatus = "TIMEOUT";
+                }
+                else if (error instanceof ReportGenerationError) {
+                    lastStatus = "FAILED";
+                }
+                this.logger.warn({
+                    error: lastError.message,
+                    queryId,
+                    reportId,
+                    attempt: attempt + 1,
+                    maxRetries,
+                    lastStatus,
+                }, "Query execution attempt failed");
+                if (attempt < maxRetries - 1) {
+                    this.logger.info({ cooldownMs: retryCooldownMs, nextAttempt: attempt + 2 }, "Waiting before retry with continuation");
+                    await delay(retryCooldownMs);
+                }
+            }
+        }
+        throw new RetryExhaustedError(maxRetries, {
+            queryId,
+            reportId,
+            lastError,
+            lastStatus,
+        });
+    }
+    async fetchReportData(gcsPath) {
+        return withBidManagerApiSpan("fetchReportData", undefined, async () => {
+            return this.fetchReportDataInner(gcsPath);
+        });
+    }
+    async fetchReportDataInner(gcsPath) {
+        this.logger.info({ gcsPath: gcsPath.substring(0, 100) + "..." }, "Fetching report data");
+        try {
+            const response = await fetch(gcsPath);
+            if (!response.ok) {
+                throw new ReportFetchError(`HTTP ${response.status}: ${response.statusText}`, gcsPath);
+            }
+            const data = await response.text();
+            this.logger.info({ bytes: data.length }, "Report data fetched successfully");
+            return data;
+        }
+        catch (error) {
+            if (error instanceof ReportFetchError) {
+                throw error;
+            }
+            this.logger.error({ error }, "Failed to fetch report data");
+            throw new ReportFetchError(error instanceof Error ? error.message : String(error), gcsPath, error);
+        }
+    }
+    async getDeliveryMetrics(params) {
+        return withBidManagerApiSpan("getDeliveryMetrics", undefined, async () => {
+            return this.getDeliveryMetricsInner(params);
+        });
+    }
+    async getDeliveryMetricsInner(params) {
+        this.logger.info({ advertiserId: params.advertiserId, campaignId: params.campaignId }, "Getting delivery metrics");
+        const querySpec = {
+            metadata: {
+                title: `Delivery metrics for campaign ${params.campaignId}`,
+                dataRange: {
+                    range: "CUSTOM_DATES",
+                    customStartDate: parseDateString(params.startDate),
+                    customEndDate: parseDateString(params.endDate),
+                },
+                format: "CSV",
+            },
+            params: {
+                type: "STANDARD",
+                groupBys: ["FILTER_DATE", "FILTER_MEDIA_PLAN", "FILTER_ADVERTISER_CURRENCY"],
+                metrics: [
+                    "METRIC_IMPRESSIONS",
+                    "METRIC_CLICKS",
+                    "METRIC_TOTAL_MEDIA_COST_ADVERTISER",
+                    "METRIC_TOTAL_CONVERSIONS",
+                    "METRIC_REVENUE_ADVERTISER",
+                ],
+                filters: [
+                    { type: "FILTER_ADVERTISER", value: params.advertiserId },
+                    { type: "FILTER_MEDIA_PLAN", value: params.campaignId },
+                ],
+            },
+        };
+        const result = await this.executeQueryWithRetry(querySpec);
+        const csvData = await this.fetchReportData(result.gcsPath);
+        const metrics = parseCSVToDeliveryMetrics(csvData);
+        this.logger.info({ advertiserId: params.advertiserId, campaignId: params.campaignId, metrics }, "Delivery metrics retrieved successfully");
+        return metrics;
+    }
+    async getHistoricalMetrics(params) {
+        return withBidManagerApiSpan("getHistoricalMetrics", undefined, async () => {
+            return this.getHistoricalMetricsInner(params);
+        });
+    }
+    async getHistoricalMetricsInner(params) {
+        this.logger.info({
+            advertiserId: params.advertiserId,
+            campaignId: params.campaignId,
+            granularity: params.granularity,
+        }, "Getting historical metrics");
+        const timeGroupBy = params.granularity === "weekly"
+            ? "FILTER_WEEK"
+            : params.granularity === "monthly"
+                ? "FILTER_MONTH"
+                : "FILTER_DATE";
+        const querySpec = {
+            metadata: {
+                title: `Historical metrics for campaign ${params.campaignId}`,
+                dataRange: {
+                    range: "CUSTOM_DATES",
+                    customStartDate: parseDateString(params.startDate),
+                    customEndDate: parseDateString(params.endDate),
+                },
+                format: "CSV",
+            },
+            params: {
+                type: "STANDARD",
+                groupBys: [timeGroupBy, "FILTER_MEDIA_PLAN", "FILTER_ADVERTISER_CURRENCY"],
+                metrics: [
+                    "METRIC_IMPRESSIONS",
+                    "METRIC_CLICKS",
+                    "METRIC_TOTAL_MEDIA_COST_ADVERTISER",
+                    "METRIC_TOTAL_CONVERSIONS",
+                    "METRIC_REVENUE_ADVERTISER",
+                ],
+                filters: [
+                    { type: "FILTER_ADVERTISER", value: params.advertiserId },
+                    { type: "FILTER_MEDIA_PLAN", value: params.campaignId },
+                ],
+            },
+        };
+        const result = await this.executeQueryWithRetry(querySpec);
+        const csvData = await this.fetchReportData(result.gcsPath);
+        const historicalData = parseCSVToHistoricalData(csvData);
+        this.logger.info({
+            advertiserId: params.advertiserId,
+            campaignId: params.campaignId,
+            dataPoints: historicalData.length,
+        }, "Historical metrics retrieved successfully");
+        return historicalData;
+    }
+    async getPacingStatus(params) {
+        return withBidManagerApiSpan("getPacingStatus", undefined, async () => {
+            return this.getPacingStatusInner(params);
+        });
+    }
+    async getPacingStatusInner(params) {
+        this.logger.info({ advertiserId: params.advertiserId, campaignId: params.campaignId }, "Getting pacing status");
+        const today = getTodayString();
+        const flightStartDate = params.flightStartDate;
+        const flightEndDate = params.flightEndDate;
+        const effectiveEndDate = today < flightEndDate ? today : flightEndDate;
+        const metrics = await this.getDeliveryMetrics({
+            advertiserId: params.advertiserId,
+            campaignId: params.campaignId,
+            startDate: flightStartDate,
+            endDate: effectiveEndDate,
+        });
+        const totalDays = daysBetween(flightStartDate, flightEndDate) + 1;
+        const daysPassed = daysBetween(flightStartDate, effectiveEndDate) + 1;
+        const daysRemaining = Math.max(0, totalDays - daysPassed);
+        const expectedDeliveryPercent = round(safeDivide(daysPassed, totalDays, 0) * 100, 2);
+        const actualDeliveryPercent = round(safeDivide(metrics.spend, params.budgetTotal, 0) * 100, 2);
+        const pacingRatio = round(safeDivide(actualDeliveryPercent, expectedDeliveryPercent, 0), 4);
+        let status;
+        if (pacingRatio >= 0.95 && pacingRatio <= 1.05) {
+            status = "ON_PACE";
+        }
+        else if (pacingRatio > 1.05) {
+            status = "AHEAD";
+        }
+        else if (pacingRatio >= 0.8) {
+            status = "BEHIND";
+        }
+        else {
+            status = "SEVERELY_BEHIND";
+        }
+        const dailySpendRate = safeDivide(metrics.spend, daysPassed, 0);
+        const projectedEndSpend = round(metrics.spend + dailySpendRate * daysRemaining, 2);
+        const pacingStatus = {
+            advertiserId: params.advertiserId,
+            campaignId: params.campaignId,
+            budgetTotal: params.budgetTotal,
+            spendToDate: metrics.spend,
+            expectedDeliveryPercent,
+            actualDeliveryPercent,
+            pacingRatio,
+            status,
+            daysRemaining,
+            projectedEndSpend,
+        };
+        this.logger.info({ advertiserId: params.advertiserId, campaignId: params.campaignId, pacingStatus }, "Pacing status calculated");
+        return pacingStatus;
+    }
+    async getPerformanceMetrics(params) {
+        return withBidManagerApiSpan("getPerformanceMetrics", undefined, async () => {
+            const delivery = await this.getDeliveryMetrics(params);
+            return calculatePerformanceMetrics(delivery);
+        });
+    }
+    async executeCustomQuery(params_) {
+        return withBidManagerApiSpan("executeCustomQuery", undefined, async () => {
+            return this.executeCustomQueryInner(params_);
+        });
+    }
+    async executeCustomQueryInner(params) {
+        this.logger.info({
+            reportType: params.reportType,
+            groupBysCount: params.groupBys.length,
+            metricsCount: params.metrics.length,
+            filtersCount: params.filters?.length || 0,
+        }, "Executing custom query");
+        let dataRangeConfig;
+        if (params.dateRange.preset) {
+            dataRangeConfig = {
+                range: params.dateRange.preset,
+            };
+        }
+        else if (params.dateRange.startDate && params.dateRange.endDate) {
+            dataRangeConfig = {
+                range: "CUSTOM_DATES",
+                customStartDate: parseDateString(params.dateRange.startDate),
+                customEndDate: parseDateString(params.dateRange.endDate),
+            };
+        }
+        else {
+            throw new BidManagerError("Invalid dateRange: provide either preset or startDate/endDate");
+        }
+        const querySpec = {
+            metadata: {
+                title: `Custom query - ${new Date().toISOString()}`,
+                dataRange: dataRangeConfig,
+                format: "CSV",
+            },
+            params: {
+                type: params.reportType,
+                groupBys: params.groupBys,
+                metrics: params.metrics,
+                filters: params.filters,
+            },
+        };
+        const queryResult = await this.executeQueryWithRetry(querySpec);
+        const csvData = await this.fetchReportData(queryResult.gcsPath);
+        if (params.outputFormat === "csv") {
+            const csvRecords = csvToJson(csvData);
+            const columns = csvRecords.length > 0 ? Object.keys(csvRecords[0]) : [];
+            const rowCount = csvRecords.length;
+            this.logger.info({ rowCount, columnsCount: columns.length }, "Custom query completed (CSV format)");
+            return {
+                queryId: queryResult.queryId,
+                reportId: queryResult.reportId,
+                status: "DONE",
+                rowCount,
+                columns,
+                data: csvData,
+            };
+        }
+        const records = csvToJson(csvData);
+        this.logger.info({ rowCount: records.length, columnsCount: Object.keys(records[0] || {}).length }, "Custom query completed (structured format)");
+        return {
+            queryId: queryResult.queryId,
+            reportId: queryResult.reportId,
+            status: "DONE",
+            rowCount: records.length,
+            columns: records.length > 0 ? Object.keys(records[0]) : [],
+            data: records,
+        };
+    }
+}
+//# sourceMappingURL=BidManagerService.js.map