@oneuptime/common 11.5.8 → 11.5.10

package/Server/API/AIAgentTaskLogAPI.ts

@@ -120,6 +120,31 @@ export default class AIAgentTaskLogAPI {
             );
           }
 
+          /*
+           * Optional verbatim tool detail (see TaskLogger.toolCall): the
+           * arguments as executed and the full output the model saw, recorded
+           * on the run's transcript for the Logs page. Absent it — an older
+           * agent — behaviour is exactly as before.
+           *
+           * The event type stays ProgressLog even when the detail is present.
+           * That is deliberate, not laziness: the Overview's ChatActivityFeed
+           * renders a ProgressLog by printing resultSummary.message, but
+           * renders a ToolCallCompleted by trying to COMPLETE a matching
+           * running step from an earlier ToolCallStarted — an event the
+           * code-fix path never emits. Typing these as ToolCallCompleted
+           * therefore matched nothing and silently erased every tool line from
+           * the Overview feed. The payload rides on the same event instead.
+           */
+          const toolName: string | undefined = data["toolName"] as
+            | string
+            | undefined;
+          const toolArguments: JSONObject | undefined = data[
+            "toolArguments"
+          ] as JSONObject | undefined;
+          const toolResult: string | undefined = data["toolResult"] as
+            | string
+            | undefined;
+
           await AIRunEventService.appendEventToRun({
             projectId: existingRun.projectId,
             aiRunId: runId,
@@ -128,6 +153,30 @@ export default class AIAgentTaskLogAPI {
               message: message,
               severity: severity,
             },
+            ...(toolName ? { toolName: toolName } : {}),
+            /*
+             * toolArguments (the column) is deliberately NOT written: its read
+             * ACL is project-member-wide, and a write_file call's arguments are
+             * the file's full new content. The same arguments go onto
+             * contentPayload below, whose read ACL is empty and which only the
+             * owner/admin-gated logs endpoint returns.
+             */
+            ...(toolName
+              ? {
+                  contentPayload: {
+                    ...(toolResult !== undefined
+                      ? { toolResult: toolResult }
+                      : {}),
+                    ...(toolArguments
+                      ? {
+                          responseToolCalls: [
+                            { name: toolName, arguments: toolArguments },
+                          ],
+                        }
+                      : {}),
+                  },
+                }
+              : {}),
           });
 
           /* A progress report proves the agent is alive — refresh the heartbeat. */

package/Server/API/AIChatAPI.ts

@@ -21,6 +21,10 @@ import SubscriptionPlan, {
 import { IsBillingEnabled, getAllEnvVars } from "../EnvironmentConfig";
 import AIChatMessageRole from "../../Types/AI/AIChatMessageRole";
 import AIChatMessageStatus from "../../Types/AI/AIChatMessageStatus";
+import {
+  AIChatPageContext,
+  AIChatPageContextHelper,
+} from "../../Types/AI/AIChatPageContext";
 import AIChatPermissionMode, {
   AIChatPermissionModeHelper,
 } from "../../Types/AI/AIChatPermissionMode";
@@ -143,6 +147,16 @@ router.post(
           ? (req.body["permissionMode"] as AIChatPermissionMode)
           : undefined;
 
+      /*
+       * Optional page context — what the user was looking at when they asked
+       * (an incident, a monitor, the logs explorer, …). It is a hint for the
+       * system prompt, so an invalid payload is dropped, never an error.
+       */
+      const pageContext: AIChatPageContext | undefined =
+        AIChatPageContextHelper.sanitize(
+          req.body["pageContext"] as JSONObject | undefined,
+        );
+
       // Plan gate: custom endpoints get no automatic billing check.
       if (
         IsBillingEnabled &&
@@ -435,6 +449,7 @@ router.post(
         aiRunId: createdRun.id!,
         llmProviderId: effectiveLlmProviderId,
         permissionMode: effectivePermissionMode,
+        pageContext: pageContext,
         props: props,
       }).catch((error: Error) => {
         logger.error(`AI chat turn crashed: ${error.message}`);
@@ -498,6 +513,7 @@ router.post(
           return {
             id: provider.id?.toString(),
             name: provider.name,
+            description: provider.description || null,
             llmType: provider.llmType?.toString() || null,
             modelName: provider.modelName || null,
             isDefault: provider.isDefault || false,

package/Server/API/AIReadinessAPI.ts

@@ -0,0 +1,84 @@
+import Express, {
+  ExpressRequest,
+  ExpressResponse,
+  ExpressRouter,
+  NextFunction,
+} from "../Utils/Express";
+import Response from "../Utils/Response";
+import UserMiddleware from "../Middleware/UserAuthorization";
+import CommonAPI from "./CommonAPI";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import NotAuthorizedException from "../../Types/Exception/NotAuthorizedException";
+import BadDataException from "../../Types/Exception/BadDataException";
+import { JSONArray } from "../../Types/JSON";
+import { AIFixReadiness } from "../../Types/AI/AIFixReadiness";
+import CodeFixReadiness from "../Utils/AI/CodeFix/CodeFixReadiness";
+
+/*
+ * Project-wide "can AI actually do anything here?" — the gates a CodeFix run
+ * passes through, answered for the whole project rather than one exception.
+ * The AI Tasks page renders this instead of a static prerequisites banner, so
+ * what the user reads reflects what the server would actually decide.
+ *
+ * The per-exception equivalent lives at
+ * GET /telemetry-exception/ai-fix-readiness/:id; both share the checks in
+ * CodeFixReadiness, so they cannot drift apart.
+ */
+const router: ExpressRouter = Express.getRouter();
+
+router.post(
+  "/ai-readiness/code-fix",
+  UserMiddleware.getUserMiddleware,
+  async (
+    req: ExpressRequest,
+    res: ExpressResponse,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const props: DatabaseCommonInteractionProps =
+        await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+      /*
+       * Authorize explicitly. getUserMiddleware admits anonymous callers
+       * (it sets userType = Public and calls next()), and tenantId is read
+       * straight off the caller-supplied `tenantid` header before any auth
+       * runs — so neither is evidence of anything on its own. The readiness
+       * checks below all query with `isRoot: true`, which means there is no
+       * RBAC layer underneath to catch an unauthorized caller: this handler
+       * is the only gate. The per-exception sibling gets away without this
+       * because it loads the exception with the caller's props first, and
+       * derives the project from that authorized row.
+       */
+      if (!props.userId) {
+        throw new NotAuthorizedException(
+          "AI readiness requires a logged-in user session.",
+        );
+      }
+
+      if (!props.tenantId) {
+        throw new BadDataException("Project ID is required (tenantid header).");
+      }
+
+      // Being logged in somewhere is not access to THIS project.
+      if (!props.userTenantAccessPermission?.[props.tenantId.toString()]) {
+        throw new NotAuthorizedException(
+          "You do not have access to this project.",
+        );
+      }
+
+      const readiness: AIFixReadiness =
+        await CodeFixReadiness.getProjectReadiness({
+          projectId: props.tenantId,
+        });
+
+      return Response.sendJsonObjectResponse(req, res, {
+        ready: readiness.ready,
+        checks: readiness.checks as unknown as JSONArray,
+      });
+    } catch (err) {
+      next(err);
+    }
+  },
+);
+
+export default router;

package/Server/API/BaseAnalyticsAPI.ts

@@ -327,6 +327,23 @@ export default class BaseAnalyticsAPI<
     );
   }
 
+  /*
+   * Server-side clamp on the client-sent aggregate limit — nothing else
+   * bounds it, so an arbitrary client could request limit=999999999
+   * rows. Clamped to LIMIT_PER_PROJECT (never lower): grouped chart
+   * queries legitimately use the full 10k (groups × buckets).
+   * Non-numeric/absent limits are left untouched for the service layer's
+   * own defaulting.
+   */
+  public static clampAggregateLimit(
+    aggregateBy: AggregateBy<AnalyticsDataModel>,
+  ): void {
+    const requestedLimit: number = Number(aggregateBy.limit);
+    if (Number.isFinite(requestedLimit) && requestedLimit > LIMIT_PER_PROJECT) {
+      aggregateBy.limit = LIMIT_PER_PROJECT;
+    }
+  }
+
   @CaptureSpan()
   public async getAggregate(
     req: ExpressRequest,
@@ -357,6 +374,12 @@ export default class BaseAnalyticsAPI<
       throw new BadRequestException("AggregateBy is required");
     }
 
+    /*
+     * Applied before the cache key is computed so an over-limit request
+     * shares the cache slot of its clamped equivalent.
+     */
+    BaseAnalyticsAPI.clampAggregateLimit(aggregateBy);
+
     const databaseProps: DatabaseCommonInteractionProps =
       await CommonAPI.getDatabaseCommonInteractionProps(req);
 

package/Server/API/CodeFixRunAPI.ts

@@ -8,21 +8,27 @@ import Express, {
 } from "../Utils/Express";
 import Response from "../Utils/Response";
 import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import DatabaseCommonInteractionPropsUtil, {
+  PermissionType,
+} from "../../Types/BaseDatabase/DatabaseCommonInteractionPropsUtil";
 import ObjectID from "../../Types/ObjectID";
 import BadDataException from "../../Types/Exception/BadDataException";
 import NotAuthorizedException from "../../Types/Exception/NotAuthorizedException";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import Select from "../Types/Database/Select";
 import { JSONObject } from "../../Types/JSON";
+import Permission, { UserPermission } from "../../Types/Permission";
 import AIRunType from "../../Types/AI/AIRunType";
 import { CodeFixTaskTypeHelper } from "../../Types/AI/CodeFixTaskType";
 import AIRun from "../../Models/DatabaseModels/AIRun";
 import AIRunEvent from "../../Models/DatabaseModels/AIRunEvent";
+import LlmLog from "../../Models/DatabaseModels/LlmLog";
 import Project from "../../Models/DatabaseModels/Project";
 import BaseModel from "../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
 import ProjectService from "../Services/ProjectService";
 import AIRunService from "../Services/AIRunService";
 import AIRunEventService from "../Services/AIRunEventService";
+import LlmLogService from "../Services/LlmLogService";
 
 const MAX_EVENTS: number = 500;
 
@@ -56,6 +62,7 @@ const RUN_SELECT: Select<AIRun> = {
   triggeredByTelemetryExceptionId: true,
   totalTokens: true,
   codeFixTaskType: true,
+  taskNumber: true,
   attemptCount: true,
   llmCallCount: true,
   toolCallCount: true,
@@ -67,6 +74,50 @@ const RUN_SELECT: Select<AIRun> = {
    */
 };
 
+/*
+ * The Logs page's event trail.
+ *
+ * toolArguments is deliberately NOT selected, even though this endpoint reads
+ * as root and could. A code-fix write_file call carries the file's full new
+ * content in its arguments, and that column's own read ACL stops at
+ * ProjectMember — narrower than this endpoint's Project-read gate, which also
+ * admits Viewers. Returning it would leak the same customer source code that
+ * contentPayload is stripped below to protect, to an even wider audience. The
+ * page never needed it: Logs.tsx renders tool arguments from
+ * contentPayload.responseToolCalls, the owner/admin-gated copy.
+ */
+const LOG_EVENT_SELECT: Select<AIRunEvent> = {
+  _id: true,
+  sequence: true,
+  eventType: true,
+  toolName: true,
+  resultSummary: true,
+  citationId: true,
+  createdAt: true,
+  contentPayload: true,
+};
+
+/*
+ * The per-LLM-call metering shown beside the transcript. Read under the
+ * CALLER's permissions (not root), so LlmLog's own table ACL decides who sees
+ * it rather than this endpoint's broader Project-read gate.
+ */
+const LLM_LOG_SELECT: Select<LlmLog> = {
+  _id: true,
+  modelName: true,
+  llmProviderName: true,
+  status: true,
+  statusMessage: true,
+  totalTokens: true,
+  completionTokens: true,
+  durationMs: true,
+  requestStartedAt: true,
+  requestCompletedAt: true,
+  createdAt: true,
+};
+
+const MAX_LLM_LOGS: number = 500;
+
 /*
  * Serialize a run with codeFixTaskType normalized: a null column means
  * FixException (rows created before task recipes existed), and clients
@@ -163,6 +214,137 @@ export default class CodeFixRunAPI {
         }
       },
     );
+
+    /*
+     * The Logs page: the same run, its FULL event trail, and the per-call LLM
+     * metering — everything recorded about a run, for debugging one that went
+     * wrong.
+     *
+     * Two things are gated more tightly than the trail itself:
+     *
+     * - contentPayload (the verbatim prompts, model replies and tool output)
+     *   is returned only to ProjectOwner/ProjectAdmin. It embeds customer
+     *   source code, which is why the column's own read ACL is empty and why
+     *   LlmLog redacts the same content — this endpoint is the single
+     *   deliberate door to it, and it is not open to every project member.
+     *
+     * - LlmLog rows are read under the CALLER's permissions rather than as
+     *   root, so LlmLog's table ACL — not this endpoint's broader Project-read
+     *   gate — decides who sees the metering.
+     */
+    this.router.post(
+      "/code-fix-run/logs/:runId",
+      UserMiddleware.getUserMiddleware,
+      async (
+        req: ExpressRequest,
+        res: ExpressResponse,
+        next: NextFunction,
+      ): Promise<void> => {
+        try {
+          const props: DatabaseCommonInteractionProps =
+            await this.getAccessCheckedProps(req);
+
+          const runIdString: string | undefined = req.params["runId"];
+
+          if (!runIdString) {
+            throw new BadDataException("runId is required.");
+          }
+
+          const runId: ObjectID = new ObjectID(runIdString);
+
+          const run: AIRun | null = await AIRunService.findOneBy({
+            query: {
+              _id: runId.toString(),
+              projectId: props.tenantId!,
+              runType: AIRunType.CodeFix,
+            },
+            select: RUN_SELECT,
+            props: { isRoot: true },
+          });
+
+          if (!run) {
+            throw new BadDataException(
+              "Code fix run not found (or it does not belong to this project).",
+            );
+          }
+
+          const canReadContent: boolean = this.callerCanReadRunContent(props);
+
+          const events: Array<AIRunEvent> = await AIRunEventService.findBy({
+            query: { aiRunId: run.id! },
+            select: LOG_EVENT_SELECT,
+            sort: { sequence: SortOrder.Ascending },
+            limit: MAX_EVENTS,
+            skip: 0,
+            props: { isRoot: true },
+          });
+
+          const eventsJson: Array<JSONObject> = BaseModel.toJSONArray(
+            events,
+            AIRunEvent,
+          );
+
+          if (!canReadContent) {
+            for (const eventJson of eventsJson) {
+              delete eventJson["contentPayload"];
+            }
+          }
+
+          /*
+           * Under the caller's own permissions on purpose — see the note
+           * above. A caller without LlmLog read simply gets no metering rows.
+           */
+          const llmLogs: Array<LlmLog> = await LlmLogService.findBy({
+            query: { aiRunId: runId, projectId: props.tenantId! },
+            select: LLM_LOG_SELECT,
+            sort: { createdAt: SortOrder.Ascending },
+            limit: MAX_LLM_LOGS,
+            skip: 0,
+            props: props,
+          });
+
+          Response.sendJsonObjectResponse(req, res, {
+            run: runToJson(run),
+            events: eventsJson,
+            llmLogs: BaseModel.toJSONArray(llmLogs, LlmLog),
+            canReadContent: canReadContent,
+          });
+          return;
+        } catch (err) {
+          next(err);
+          return;
+        }
+      },
+    );
+  }
+
+  /*
+   * Whether the caller may see a run's verbatim LLM/tool content. Project
+   * owners and admins only: the content embeds customer source code, so the
+   * bar is higher than the Project-read gate that admits them to the page.
+   *
+   * Read through getUserPermissions(Allow) rather than off
+   * userTenantAccessPermission directly, because that array holds GRANTS AND
+   * DENIALS together, discriminated only by isBlockPermission. Mapping it raw
+   * counts a team's explicit "block ProjectAdmin" entry as a grant of
+   * ProjectAdmin — inverting the control, so the admin action that restricts a
+   * team would be what hands it the source code.
+   */
+  private callerCanReadRunContent(
+    props: DatabaseCommonInteractionProps,
+  ): boolean {
+    const permissions: Array<Permission> =
+      DatabaseCommonInteractionPropsUtil.getUserPermissions(
+        props,
+        PermissionType.Allow,
+      ).map((userPermission: UserPermission) => {
+        return userPermission.permission;
+      });
+
+    return (
+      permissions.includes(Permission.ProjectOwner) ||
+      permissions.includes(Permission.ProjectAdmin)
+    );
   }
 
   /*

package/Server/API/EnterpriseLicenseAPI.ts

@@ -32,6 +32,7 @@ export interface LicenseInstanceUpsert {
   // Usage fields are only set on report-user-count, not on validate.
   userCount?: number | undefined;
   userEmailHashes?: Array<string> | undefined;
+  masterAdminEmails?: Array<string> | undefined;
   lastReportedAt?: Date | undefined;
 }
 
@@ -215,6 +216,10 @@ export default class EnterpriseLicenseAPI extends BaseAPI<
             EnterpriseLicenseUsageUtil.sanitizeUserEmailHashes(
               req.body["userEmailHashes"],
             );
+          const masterAdminEmails: Array<string> =
+            EnterpriseLicenseUsageUtil.sanitizeMasterAdminEmails(
+              req.body["masterAdminEmails"],
+            );
 
           if (instanceId) {
             /*
@@ -227,6 +232,7 @@ export default class EnterpriseLicenseAPI extends BaseAPI<
               host: instanceHost || undefined,
               userCount: userCount,
               userEmailHashes: userEmailHashes,
+              masterAdminEmails: masterAdminEmails,
               lastReportedAt: reportedAt,
             });
           }
@@ -372,6 +378,10 @@ export default class EnterpriseLicenseAPI extends BaseAPI<
       newInstance.userEmailHashes = data.userEmailHashes;
     }
 
+    if (data.masterAdminEmails !== undefined) {
+      newInstance.masterAdminEmails = data.masterAdminEmails;
+    }
+
     if (data.lastReportedAt !== undefined) {
       newInstance.lastReportedAt = data.lastReportedAt;
     }
@@ -432,6 +442,10 @@ export default class EnterpriseLicenseAPI extends BaseAPI<
       updateData.userEmailHashes = data.userEmailHashes;
     }
 
+    if (data.masterAdminEmails !== undefined) {
+      updateData.masterAdminEmails = data.masterAdminEmails;
+    }
+
     if (data.lastReportedAt !== undefined) {
       updateData.lastReportedAt = data.lastReportedAt;
     }

package/Server/API/TelemetryExceptionAPI.ts

@@ -4,11 +4,11 @@ import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
 import BaseModel from "../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
 import TelemetryExceptionService, {
-  AIFixReadiness,
   DashboardServiceSummary,
   DashboardSummaryResult,
   Service as TelemetryExceptionServiceType,
 } from "../Services/TelemetryExceptionService";
+import { AIFixReadiness } from "../../Types/AI/AIFixReadiness";
 import AIRunService from "../Services/AIRunService";
 import UserMiddleware from "../Middleware/UserAuthorization";
 import Response from "../Utils/Response";
@@ -51,6 +51,11 @@ const CODE_FIX_STATUS_TEXT: {
     description:
       "The AI agent finished. Review the pull request it opened for the proposed fix.",
   },
+  [AIRunStatus.NoFixFound]: {
+    title: "No Fix Found",
+    description:
+      "The AI agent reviewed the code and did not find a fix to propose, so it opened no pull request.",
+  },
   [AIRunStatus.Error]: {
     title: "Error",
     description: "The AI agent could not complete the fix.",

package/Server/EnvironmentConfig.ts

@@ -337,6 +337,90 @@ export const SubscriptionPlans: Array<SubscriptionPlan> =
 export const AnalyticsKey: string = process.env["ANALYTICS_KEY"] || "";
 export const AnalyticsHost: string = process.env["ANALYTICS_HOST"] || "";
 
+/*
+ * Google Ads offline conversion uploads (MarketingConversions worker job).
+ * Server-only secrets — must never be added to FRONTEND_ENV_ALLOW_LIST.
+ */
+export const GoogleAdsDeveloperToken: string =
+  process.env["GOOGLE_ADS_DEVELOPER_TOKEN"] || "";
+export const GoogleAdsOAuthClientId: string =
+  process.env["GOOGLE_ADS_OAUTH_CLIENT_ID"] || "";
+export const GoogleAdsOAuthClientSecret: string =
+  process.env["GOOGLE_ADS_OAUTH_CLIENT_SECRET"] || "";
+export const GoogleAdsOAuthRefreshToken: string =
+  process.env["GOOGLE_ADS_OAUTH_REFRESH_TOKEN"] || "";
+// Digits only, no dashes (e.g. 1234567890).
+export const GoogleAdsCustomerId: string =
+  process.env["GOOGLE_ADS_CUSTOMER_ID"] || "";
+// Manager (MCC) account id when the OAuth user accesses the account via a manager.
+export const GoogleAdsLoginCustomerId: string =
+  process.env["GOOGLE_ADS_LOGIN_CUSTOMER_ID"] || "";
+/*
+ * Google sunsets Ads API versions roughly yearly (v20 died 2026-06-10) —
+ * keep this default on a currently supported version and prefer setting
+ * GOOGLE_ADS_API_VERSION explicitly in production.
+ */
+export const GoogleAdsApiVersion: string =
+  process.env["GOOGLE_ADS_API_VERSION"] || "v23";
+// Numeric conversion action ids from Google Ads (Goals -> Conversions).
+export const GoogleAdsSignUpConversionActionId: string =
+  process.env["GOOGLE_ADS_SIGNUP_CONVERSION_ACTION_ID"] || "";
+export const GoogleAdsPaidSubscriptionConversionActionId: string =
+  process.env["GOOGLE_ADS_PAID_SUBSCRIPTION_CONVERSION_ACTION_ID"] || "";
+
+// Meta (Facebook) Conversions API. Server-only secrets.
+export const MetaConversionsPixelId: string =
+  process.env["META_CONVERSIONS_PIXEL_ID"] || "";
+export const MetaConversionsAccessToken: string =
+  process.env["META_CONVERSIONS_ACCESS_TOKEN"] || "";
+export const MetaGraphApiVersion: string =
+  process.env["META_GRAPH_API_VERSION"] || "v22.0";
+
+// Microsoft Advertising (Bing Ads) offline conversions. Server-only secrets.
+export const MicrosoftAdsDeveloperToken: string =
+  process.env["MICROSOFT_ADS_DEVELOPER_TOKEN"] || "";
+export const MicrosoftAdsOAuthClientId: string =
+  process.env["MICROSOFT_ADS_OAUTH_CLIENT_ID"] || "";
+export const MicrosoftAdsOAuthClientSecret: string =
+  process.env["MICROSOFT_ADS_OAUTH_CLIENT_SECRET"] || "";
+export const MicrosoftAdsOAuthRefreshToken: string =
+  process.env["MICROSOFT_ADS_OAUTH_REFRESH_TOKEN"] || "";
+export const MicrosoftAdsCustomerId: string =
+  process.env["MICROSOFT_ADS_CUSTOMER_ID"] || "";
+export const MicrosoftAdsAccountId: string =
+  process.env["MICROSOFT_ADS_ACCOUNT_ID"] || "";
+// Offline conversion goals are matched by NAME in Microsoft Advertising.
+export const MicrosoftAdsSignUpConversionName: string =
+  process.env["MICROSOFT_ADS_SIGNUP_CONVERSION_NAME"] || "";
+export const MicrosoftAdsPaidSubscriptionConversionName: string =
+  process.env["MICROSOFT_ADS_PAID_SUBSCRIPTION_CONVERSION_NAME"] || "";
+
+// LinkedIn Conversions API. Server-only secrets.
+export const LinkedInConversionsAccessToken: string =
+  process.env["LINKEDIN_CONVERSIONS_ACCESS_TOKEN"] || "";
+/*
+ * LinkedIn publishes a new Marketing API version monthly and supports each
+ * for ~12 months — keep this default recent and prefer setting
+ * LINKEDIN_API_VERSION explicitly in production.
+ */
+export const LinkedInApiVersion: string =
+  process.env["LINKEDIN_API_VERSION"] || "202606";
+// Numeric conversion rule ids (urn:lla:llaPartnerConversion:{id}).
+export const LinkedInSignUpConversionId: string =
+  process.env["LINKEDIN_SIGNUP_CONVERSION_ID"] || "";
+export const LinkedInPaidSubscriptionConversionId: string =
+  process.env["LINKEDIN_PAID_SUBSCRIPTION_CONVERSION_ID"] || "";
+
+// Reddit Conversions API. Server-only secrets.
+export const RedditAdsOAuthClientId: string =
+  process.env["REDDIT_ADS_OAUTH_CLIENT_ID"] || "";
+export const RedditAdsOAuthClientSecret: string =
+  process.env["REDDIT_ADS_OAUTH_CLIENT_SECRET"] || "";
+export const RedditAdsOAuthRefreshToken: string =
+  process.env["REDDIT_ADS_OAUTH_REFRESH_TOKEN"] || "";
+export const RedditAdsAccountId: string =
+  process.env["REDDIT_ADS_ACCOUNT_ID"] || "";
+
 export const DisableAutomaticIncidentCreation: boolean =
   process.env["DISABLE_AUTOMATIC_INCIDENT_CREATION"] === "true";