@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v3/google-ads/app/server/src/app/api/routes/setConversionMappings.ts

@@ -0,0 +1,46 @@
+import { HttpRequest, InvocationContext } from "@azure/functions";
+import { Logger } from "winston";
+import {AppUiHttpRequestResponse, createOrUpdateInstallation} from "@seeka-labs/sdk-apps-server-host";
+import {
+    GoogleAdsAppInstallContext,
+    SeekaActivityToGoogleConversionActionMapping
+} from "@seeka-labs-apps/google-ads-lib";
+
+export const setConversionMappings = async (installation: GoogleAdsAppInstallContext, req: HttpRequest, context: InvocationContext, logger: Logger): Promise<AppUiHttpRequestResponse> => {
+    // Validate
+    const body = (await req.json()) as any;
+    const mappings = body.mappings as SeekaActivityToGoogleConversionActionMapping[] | undefined;
+    if (!mappings) {
+        return {
+            status: 400,
+            jsonBody: { error: 'mappings is required' }
+        };
+    }
+
+    // TODO: valiodation from shared lib
+    // try {
+    //     GoogleConversionMappingFormSchema.validateSync({ mappings }, { abortEarly: false });
+    // }
+    // catch (err) {
+    //     const validationError = (err as ValidationError)
+    //     if (validationError.inner) {
+    //         return {
+    //             status: 400,
+    //             jsonBody: { errors: validationError.inner }
+    //         };
+    //     }
+    // }
+
+    installation.installationState = {
+        ...installation.installationState,
+        conversions: {
+            ...installation.installationState.conversions,
+            serverConversions: mappings
+        },
+    };
+    await createOrUpdateInstallation(installation, logger);
+
+    return {
+        status: 200
+    };
+}

package/dist/ai-context/internal/examples/v3/google-ads/app/server/src/app/api/routes/setGoogleCustomerId.ts

@@ -0,0 +1,39 @@
+import { HttpRequest, InvocationContext } from "@azure/functions";
+import { Logger } from "winston";
+import {AppUiHttpRequestResponse, createOrUpdateInstallation} from "@seeka-labs/sdk-apps-server-host";
+import {GoogleAdsAppInstallContext} from "@seeka-labs-apps/google-ads-lib";
+import {getAccessibleCustomers} from "../../services/google/customers";
+
+export const setGoogleCustomerId = async (installation: GoogleAdsAppInstallContext, req: HttpRequest, context: InvocationContext, logger: Logger): Promise<AppUiHttpRequestResponse> => {
+    // Validate
+    const body = (await req.json()) as any;
+    const customerId = body.customerId;
+    const rootCustomerId = body.rootCustomerId;
+    if (!customerId) {
+        return {
+            status: 400,
+            jsonBody: { error: 'customerId is required' }
+        };
+    }
+    const availableCustomers = await getAccessibleCustomers(true, installation, logger);
+    const exists = availableCustomers?.find(e => rootCustomerId ? Boolean((e.customerId === rootCustomerId && e.children?.find(a => a.customerId === customerId))) : e.customerId === customerId);
+    if (!exists) {
+        // logger.error(`Customer ID ${customerId} is not available in the installation state`, { customerId, rootCustomerId, availableCustomers });
+        return {
+            status: 400,
+            jsonBody: { error: 'customerId is not available' }
+        };
+    }
+
+    installation.installationState = {
+        ...installation.installationState,
+        googleAdsAvailableCustomers: availableCustomers,
+        googleAdsCustomerId: customerId,
+        googleAdsRootCustomerId: rootCustomerId,
+    };
+    await createOrUpdateInstallation(installation, logger);
+
+    return {
+        status: 200
+    };
+}

package/dist/ai-context/internal/examples/v3/google-ads/app/server/src/app/api/routes/setTrackingSettings.ts

@@ -0,0 +1,41 @@
+import { HttpRequest, InvocationContext } from "@azure/functions";
+import { ConvergeTrackingConfiguration } from "@seeka-labs/sdk-apps-server";
+import { Logger } from "winston";
+import {AppUiHttpRequestResponse, createOrUpdateInstallation} from "@seeka-labs/sdk-apps-server-host";
+import {GoogleAdsAppInstallContext} from "@seeka-labs-apps/google-ads-lib";
+
+export const setTrackingSettings = async (installation: GoogleAdsAppInstallContext, req: HttpRequest, context: InvocationContext, logger: Logger): Promise<AppUiHttpRequestResponse> => {
+    // Validate
+    const body = (await req.json()) as any;
+    const trackingSettings = body.trackingSettings as ConvergeTrackingConfiguration | undefined;
+    if (!trackingSettings) {
+        return {
+            status: 400,
+            jsonBody: { error: 'trackingSettings is required' }
+        };
+    }
+
+    // TODO: valiodation from shared lib
+    // try {
+    //     GoogleConversionMappingFormSchema.validateSync({ mappings }, { abortEarly: false });
+    // }
+    // catch (err) {
+    //     const validationError = (err as ValidationError)
+    //     if (validationError.inner) {
+    //         return {
+    //             status: 400,
+    //             jsonBody: { errors: validationError.inner }
+    //         };
+    //     }
+    // }
+
+    installation.installationState = {
+        ...installation.installationState,
+        trackingSettings
+    };
+    await createOrUpdateInstallation(installation, logger);
+
+    return {
+        status: 200
+    };
+}

package/dist/ai-context/internal/examples/v3/google-ads/app/server/src/app/jobs/index.ts

@@ -0,0 +1,62 @@
+import { QueueClient, QueueSendMessageOptions } from '@azure/storage-queue';
+import type { Logger } from 'winston';
+import {BackgroundJobRequestContext} from "@seeka-labs/sdk-apps-server-host";
+
+export const queueNames = {
+    trackGoogleAdsConversion: 'google-ads-conv-action-track-queue',
+    legacyMediateSeekaActivity: 'google-ads-conversion-track-queue',
+}
+
+export const triggerBackgroundJob = async <TPayload>(queueName: string, context: BackgroundJobRequestContext<TPayload>, logger: Logger, queueSendOptions?: QueueSendMessageOptions): Promise<void> => {
+    const queueClient = new QueueClient(process.env.AzureWebJobsStorage as string, queueName);
+    return await triggerBackgroundJobWithQueue(queueClient, context, logger, queueSendOptions);
+}
+
+const serialiseQueuePayload = (payload: unknown): string => {
+    const jsonString = JSON.stringify(payload)
+    return Buffer.from(jsonString).toString('base64')
+}
+
+export const deserialiseQueuePayload = <TPayload>(payload: string): TPayload => {
+    const jsonString = Buffer.from(payload, 'base64').toString()
+    return JSON.parse(jsonString) as TPayload;
+}
+
+export const triggerBackgroundJobWithQueue = async <TPayload>(queueClient: QueueClient, context: BackgroundJobRequestContext<TPayload>, logger: Logger, queueSendOptions?: QueueSendMessageOptions): Promise<void> => {
+    const body = {
+        ...context
+    }
+    const bodyStr = serialiseQueuePayload(body);
+
+    const response = await queueClient.sendMessage(bodyStr, queueSendOptions);
+
+    if (response.errorCode) {
+        const { requestId, date, errorCode } = response;
+        logger.error("Failed to trigger background job", { body, requestId, date, errorCode })
+        throw new Error(`Failed to trigger background job: ${response.errorCode}`);
+    }
+    else {
+        logger.info("Background job triggered for " + queueClient.name, { body, messageId: response.messageId, context })
+    }
+}
+
+export const sendQueueMessageToPoisonQueue = async <TPayload>(queueName: string, context: BackgroundJobRequestContext<TPayload>, logger: Logger): Promise<void> => {
+    const body = {
+        ...context
+    }
+    const bodyStr = serialiseQueuePayload(body);
+
+    // https://learn.microsoft.com/en-us/azure/azure-functions/functions-bindings-storage-queue-trigger?tabs=python-v2%2Cisolated-process%2Cnodejs-v4%2Cextensionv5&pivots=programming-language-typescript#poison-messages
+    const queueClient = new QueueClient(process.env.AzureWebJobsStorage as string, `${queueName}-poison`);
+
+    const response = await queueClient.sendMessage(bodyStr, { messageTimeToLive: -1 });
+
+    if (response.errorCode) {
+        const { requestId, date, errorCode } = response;
+        logger.error("Failed to push to poison queue", { body, requestId, date, errorCode })
+        throw new Error(`Failed to push to poison queue: ${response.errorCode}`);
+    }
+    else {
+        logger.verbose("Message pushed to poison queue", { body, messageId: response.messageId, context })
+    }
+}

package/dist/ai-context/internal/examples/v3/google-ads/app/server/src/app/logging/index.ts

@@ -0,0 +1,4 @@
+import * as packageJson from '../../../package.json';
+import {registerSeekaAppOpenTelemetry} from "@seeka-labs/sdk-apps-server-telemetry-logging";
+
+registerSeekaAppOpenTelemetry(packageJson.name, packageJson.version, 'azure', 'azure_function', process.env);

package/dist/ai-context/internal/examples/v3/google-ads/app/server/src/app/models/index.ts

@@ -0,0 +1,12 @@
+
+import {SeekaActivityAcceptedWebhookContent} from "@seeka-labs/sdk-apps-server";
+import { BackgroundJobRequestContext } from "@seeka-labs/sdk-apps-server-host";
+
+export type TrackGoogleAdsActivityQueueItem = BackgroundJobRequestContext<TrackSeekaGoogleAdsActivityPayload> & {
+
+}
+
+export type TrackSeekaGoogleAdsActivityPayload = {
+    seekaActivity: SeekaActivityAcceptedWebhookContent
+}
+

package/dist/ai-context/internal/examples/v3/google-ads/app/server/src/app/services/activites.ts

@@ -0,0 +1,8 @@
+
+import {Logger} from "winston";
+import {TrackSeekaGoogleAdsActivityPayload} from "../models";
+import {SeekaAppInstallContext} from "@seeka-labs/sdk-apps-core";
+
+export const sendActivityToAnotherSoftware = async (payload: TrackSeekaGoogleAdsActivityPayload, installation: SeekaAppInstallContext<any>, causationId: string, correlationId: string, logger: Logger): Promise<void> => {
+ // Anything
+}

package/dist/ai-context/internal/examples/v3/google-ads/app/server/src/app/services/google/ads.ts

@@ -0,0 +1,47 @@
+import { Customer, GoogleAdsApi } from "google-ads-api";
+
+import { decryptText } from "@seeka-labs/sdk-apps-server";
+import { Logger } from "winston";
+
+import { GoogleAccessToken } from './auth';
+import {GoogleAdsAppInstallContext} from "@seeka-labs-apps/google-ads-lib";
+
+export type GoogleAdsClientInfo = { client: GoogleAdsApi, token: GoogleAccessToken }
+
+export const getGoogleAdsClient = async (installation: GoogleAdsAppInstallContext, _logger: Logger): Promise<GoogleAdsClientInfo> => {
+
+  const creds = JSON.parse(process.env.GOOGLE_CLOUD_SERVICEACCOUNT_CREDS_JSON as string);
+
+  const client = new GoogleAdsApi({
+    client_id: creds.web.client_id,
+    client_secret: creds.web.client_secret,
+    developer_token: process.env.GOOGLE_ADS_DEVELOPER_TOKEN as string,
+  });
+
+  const tokenEncrypted = installation.installationState.googleAccessToken;
+  if (!tokenEncrypted) {
+    throw new Error("Google Access Token not present");
+  }
+  const token = JSON.parse(decryptText(tokenEncrypted, process.env.DATA_ENCRYPTION_KEY as string)) as GoogleAccessToken;
+  if (!token.refresh_token) {
+    throw new Error("Google Refresh Token not present ");
+  }
+
+  return { client, token };
+}
+
+export const getGoogleAdsCustomerClient = async (installation: GoogleAdsAppInstallContext, customerId: string | null, rootCustomerId: string | null, logger: Logger): Promise<Customer> => {
+  const customerIdValue = customerId || installation?.installationState?.googleAdsCustomerId;
+  if (!customerIdValue) {
+    throw new Error("Google Ads Customer ID not present");
+  }
+
+  const clientInfo = await getGoogleAdsClient(installation, logger);
+  const { client, token } = clientInfo;
+
+  return client.Customer({
+    customer_id: customerIdValue,
+    login_customer_id: rootCustomerId || installation?.installationState?.googleAdsRootCustomerId || undefined,
+    refresh_token: token.refresh_token as string,
+  });
+}

package/dist/ai-context/internal/examples/v3/google-ads/app/server/src/app/services/google/auth.ts

@@ -0,0 +1,126 @@
+import { Logger } from 'winston';
+
+import { decryptText, encryptText } from '@seeka-labs/sdk-apps-server';
+import type { Credentials, TokenInfo } from 'google-auth-library';
+import { OAuth2Client } from 'google-auth-library';
+import {createOrUpdateInstallation, tryGetInstallation} from "@seeka-labs/sdk-apps-server-host";
+import {GoogleAdsAppInstallContext} from "@seeka-labs-apps/google-ads-lib";
+
+export const handleGoogleAuthCallback = async (seekaAppInstallId: string, url: URL, logger: Logger): Promise<GoogleAdsAppInstallContext> => {
+    let installation: GoogleAdsAppInstallContext | null = null;
+    installation = await tryGetInstallation(seekaAppInstallId as string, false, logger);
+    if (installation == null) {
+        logger.error('Auth callback cannot be processed as the installation ID is not known by this app', { seekaAppInstallId });
+
+        throw new Error('App not installed');
+    }
+
+    const token = await getInitialGoogleOAuthToken(url, logger);
+    if (!token) {
+        throw new Error('Failed to get Google OAuth token');
+    }
+
+    // logger.info('hereee Token', { token });
+
+    installation.installationState.googleAccessToken = encryptText(JSON.stringify(token.token), process.env.DATA_ENCRYPTION_KEY as string);
+
+    installation.installationState.linkedGoogleAdsUser = {
+        email: token.info.email
+    }
+    return await createOrUpdateInstallation(installation, logger);
+}
+
+const getAuthClient = async (redirectUrl: string | null, logger: Logger): Promise<OAuth2Client> => {
+    const creds = JSON.parse(process.env.GOOGLE_CLOUD_SERVICEACCOUNT_CREDS_JSON as string);
+
+    return new OAuth2Client({
+        clientId: creds.web.client_id,
+        clientSecret: creds.web.client_secret,
+        redirectUri: redirectUrl,
+    });
+}
+
+export const googleScopes = ['email', 'profile', 'https://www.googleapis.com/auth/adwords', 'https://www.googleapis.com/auth/userinfo.profile', 'https://www.googleapis.com/auth/userinfo.email'];
+
+export const getAuthUrl = async (seekaAppId: string, seekaAppInstallId: string, appAccessToken: string, logger: Logger): Promise<string> => {
+    const redirectUrl = process.env.SELF_HOST_BASEURL + '/api/auth/callback/google';
+    const oAuth2Client = await getAuthClient(redirectUrl, logger);
+
+    const state = encryptText(appAccessToken, process.env.DATA_ENCRYPTION_KEY as string);
+
+    const authorizeUrl = oAuth2Client.generateAuthUrl({
+        access_type: 'offline',
+        scope: googleScopes,
+        state: state,
+        redirect_uri: redirectUrl,
+        // enable_serial_consent: true,
+        include_granted_scopes: true,
+        prompt: 'consent',
+        // login_hint: undefined, // login username if known
+        // scope: 'https://www.googleapis.com/auth/adwords',
+    });
+
+    return authorizeUrl;
+}
+
+const getOAuthToken = async (code: string, oAuth2Client: OAuth2Client, logger: Logger): Promise<GoogleAccessToken> => {
+    return new Promise((resolve, reject) => {
+        oAuth2Client.getToken(code, (err, token, res) => {
+            if (err) {
+                reject(err);
+            } else {
+                resolve(token);
+            }
+        });
+    });
+}
+
+const getInitialGoogleOAuthToken = async (reqUrl: URL, logger: Logger): Promise<{ token: GoogleAccessToken, info: TokenInfo } | undefined> => {
+    const redirectUrl = process.env.SELF_HOST_BASEURL + '/api/auth/callback/google';
+    const oAuth2Client = await getAuthClient(redirectUrl, logger);
+
+    const code = reqUrl.searchParams.get('code');
+
+    try {
+        const tokens = await getOAuthToken(code, oAuth2Client, logger);
+        const info = await oAuth2Client.getTokenInfo(tokens.access_token);
+
+        return {
+            token: tokens,
+            info
+        };
+    }
+    catch (err) {
+
+        logger.error('Failed to get initial Google OAuth token', { ex: err });
+        return undefined;
+    }
+}
+
+export const getGoogleAccessToken = async (installation: GoogleAdsAppInstallContext, logger: Logger): Promise<GoogleAccessToken> => {
+    let token = JSON.parse(decryptText(installation.installationState.googleAccessToken, process.env.DATA_ENCRYPTION_KEY as string)) as GoogleAccessToken;
+
+    if (token.expiry_date < Date.now()) {
+        logger.debug('Access token has expired, refreshing')
+        token = await refreshGoogleAccessToken(token, logger);
+        installation.installationState.googleAccessToken = encryptText(JSON.stringify(token), process.env.DATA_ENCRYPTION_KEY as string);
+        await createOrUpdateInstallation(installation, logger);
+    }
+
+    return token;
+}
+
+const refreshGoogleAccessToken = async (existingToken: GoogleAccessToken, logger: Logger): Promise<GoogleAccessToken> => {
+    const oAuth2Client = await getAuthClient(null, logger);
+    oAuth2Client.setCredentials(existingToken);
+
+    const newToken = await oAuth2Client.getAccessToken();
+    const tokenInfo = await oAuth2Client.getTokenInfo(newToken.token);
+
+    return {
+        access_token: newToken.token,
+        ...tokenInfo
+    };
+}
+
+export type GoogleAccessToken = Credentials

package/dist/ai-context/internal/examples/v3/google-ads/app/server/src/app/services/google/conversions/actions.ts

@@ -0,0 +1,102 @@
+import { enums, resources } from "google-ads-api";
+import { Logger } from "winston";
+import { getGoogleAdsCustomerClient } from "../ads";
+import {GoogleAdsAppInstallContext, GoogleAdsConversionActionInfo} from "@seeka-labs-apps/google-ads-lib";
+
+/**
+ * Extracts the AW ID and conversion label from a gtag conversion snippet string
+ *
+ * @param snippet The raw HTML/JS snippet returned from Google Ads API (containing `send_to`)
+ * @returns { awId: string; label: string } or null if not found
+ */
+export function extractSendTo(snippet: string): { conversionId: string; conversionLabel: string } | null {
+    // Match the send_to property: e.g. 'AW-16612851473/dEKZCOGis_AaEJH-z_E9'
+    const match = snippet.match(/'send_to'\s*:\s*'([^']+)'/);
+
+    if (!match) {
+        return null; // send_to not found
+    }
+
+    const sendTo = match[1]; // full AW-xxx/label string
+    const [awId, label] = sendTo.split("/");
+
+    if (!awId || !label) {
+        return null; // badly formed send_to
+    }
+
+    return { conversionId: awId, conversionLabel: label };
+}
+
+
+export const listConversionActions = async (
+    customerId: string,
+    rootCustomerId: string | null,
+    installation: GoogleAdsAppInstallContext,
+    logger: Logger
+): Promise<GoogleAdsConversionActionInfo[] | null> => {
+    // initialize API client + get refresh token
+    const customer = await getGoogleAdsCustomerClient(installation, customerId, rootCustomerId, logger)
+
+    try {
+        // GAQL query to pull every conversion_action field we care about
+        // 
+        const rows = await customer.query(`
+      SELECT
+        conversion_action.resource_name,
+        conversion_action.id,
+        conversion_action.name,
+        conversion_action.status,
+        conversion_action.type,
+        conversion_action.category,
+        conversion_action.tag_snippets
+      FROM
+        conversion_action
+      ORDER BY conversion_action.name
+    `);
+        // map into a strongly-typed array
+        return rows.map((row: { conversion_action: resources.IConversionAction }) => {
+            let info: GoogleAdsConversionActionInfo = {
+                resourceName: row.conversion_action.resource_name,
+                id: Number(row.conversion_action.id),
+                name: row.conversion_action.name,
+                status: enums.ConversionActionStatus[row.conversion_action.status] as string,
+                type: enums.ConversionActionType[row.conversion_action.type] as string,
+                category: enums.ConversionActionCategory[row.conversion_action.category] as string,
+            }
+
+            const tagSnippets = row.conversion_action.tag_snippets?.map(e => {
+                const conversionDetails = extractSendTo(e.event_snippet)
+                return {
+                    type: enums.TrackingCodeType[e.type] as string,
+                    pageFormat: enums.TrackingCodePageFormat[e.page_format] as string,
+                    globalSiteTag: e.global_site_tag,
+                    eventSnippet: e.event_snippet,
+                    ...conversionDetails
+                }
+            }) || []
+
+            const conversionLabels = tagSnippets.filter(e => e.conversionId && e.conversionLabel);
+            if (conversionLabels.length === 0) {
+                logger.warn("No conversion labels found for conversion action", { info, tagSnippets });
+            }
+            else if (conversionLabels.length === 1) {
+                info.conversionLabel = conversionLabels[0].conversionLabel;
+                info.conversionId = conversionLabels[0].conversionId;
+            }
+            else {
+                logger.warn("Multiple conversion labels found for conversion action, using first", { conversionLabels, info });
+                info.conversionLabel = conversionLabels[0].conversionLabel;
+                info.conversionId = conversionLabels[0].conversionId;
+            }
+
+            return info
+        });
+    } catch (err) {
+        logger.error(
+            `Failed to list conversion actions for customer ${customerId}`,
+            err
+        );
+
+        return null
+    }
+};

package/dist/ai-context/internal/examples/v3/google-ads/app/server/src/app/services/google/conversions/mediate.ts

@@ -0,0 +1,177 @@
+import winston, {Logger} from "winston";
+
+import {InvocationContext} from "@azure/functions";
+import {matchActivityPipelineFilters, SeekaActivityAcceptedWebhookContent} from "@seeka-labs/sdk-apps-server";
+import {Customer, enums} from 'google-ads-api';
+import {getGoogleAdsCustomerClient} from "../ads";
+import {
+    LegacyMediateSeekaActivityQueueItem,
+    TrackGoogleAdsConversionQueueItem,
+    TrackSeekaGoogleAdsConversionPayload
+} from "../queues/models";
+import {GoogleAdsConversionActionInfoWithEnum} from "./models";
+import {fireConversionAdjustment} from "./services/adjustment";
+import {fireAdCallConversion} from "./services/call";
+import {fireClickConversion} from "./services/click";
+import {toEnumConversionAction} from "./utils";
+import {
+    createSeekaTelemetryClient,
+    createEgressTelemetryRecord
+} from "@seeka-labs/sdk-apps-server-telemetry-core";
+import {
+    ActivityEgressTelemetryRecordBase,
+    ActivityEgressTelemetryRecordMetrics
+} from "@seeka-labs/sdk-apps-server-telemetry-core";
+import {GoogleAdsAppInstallContext} from "@seeka-labs-apps/google-ads-lib";
+import {queueNames, triggerBackgroundJob} from "../../../jobs";
+
+
+export const legacyMediateSeekaActivity = async (queueItem: LegacyMediateSeekaActivityQueueItem, installation: GoogleAdsAppInstallContext, context: InvocationContext, logger: Logger): Promise<void> => {
+    const conversionPayloads = await convertSeekaActivityToGoogleAdsConversions(queueItem.payload.content, installation, logger);
+
+    if (!conversionPayloads || conversionPayloads.length === 0) {
+        logger.debug("No conversion payloads to process for seeka activity", {seekaActivity: queueItem.payload.content});
+        return;
+    }
+
+    for (const conversionPayload of conversionPayloads) {
+        await triggerBackgroundJob(queueNames.trackGoogleAdsConversion, {
+            payload: conversionPayload,
+            organisationBrandId: installation.organisationBrandId,
+            organisationId: installation.organisationId,
+            applicationInstallId: installation.applicationInstallId,
+            causationId: context.invocationId,
+            correlationId: context.invocationId
+        } as TrackGoogleAdsConversionQueueItem, logger)
+    }
+}
+
+export const convertSeekaActivityToGoogleAdsConversions = async (seekaActivity: SeekaActivityAcceptedWebhookContent, installation: GoogleAdsAppInstallContext, logger: Logger): Promise<TrackSeekaGoogleAdsConversionPayload[] | undefined> => {
+    if (!installation.installationState.googleAdsCustomerId) {
+        logger.verbose("No Google Ads customer ID found in installation state")
+        return undefined;
+    }
+    const conversionMappings = (installation.installationState.conversions?.serverConversions || []).filter(e => Boolean(e) && e.active && e.googleConversionAction && e.googleConversionAction.id && e.seekaActivityMatch && e.seekaActivityMatch?.activityNames && e.seekaActivityMatch?.activityNames.length > 0);
+    if (conversionMappings.length === 0) {
+        logger.verbose("No conversion mappings found in installation state")
+        return undefined;
+    }
+
+    const payloads: TrackSeekaGoogleAdsConversionPayload[] = [];
+    for (const conversionMapping of conversionMappings) {
+        const matched = matchActivityPipelineFilters(seekaActivity, [conversionMapping.seekaActivityMatch], logger)
+        if (matched.length === 0) {
+            logger.verbose('Activity does not match conversion mapping', {conversionMapping, seekaActivity});
+            continue;
+        }
+        logger.verbose('Activity matches conversion mapping', {conversionMapping, seekaActivity});
+
+        payloads.push({
+            seekaActivity,
+            mapping: conversionMapping
+        });
+    }
+
+    return payloads.length > 0 ? payloads : undefined;
+}
+
+export type EgressMetricInfo = {
+    egressRecord: ActivityEgressTelemetryRecordBase,
+    egressMetrics: ActivityEgressTelemetryRecordMetrics
+}
+
+// order_1754041786835
+export const sendActivityAsGoogleAdsConversion = async (payload: TrackSeekaGoogleAdsConversionPayload, installation: GoogleAdsAppInstallContext, causationId: string, correlationId: string, logger: Logger): Promise<void> => {
+    const conversionMapping = payload.mapping;
+
+    const seekaActivity = payload.seekaActivity;
+
+    // Google IDs
+    const googleClickIds = (seekaActivity.identifiers?.google?.gclid || []).filter(e => Boolean(e) && e.length > 10);
+
+    const customer = await getGoogleAdsCustomerClient(installation, null, null, logger);
+
+    const matched = matchActivityPipelineFilters(seekaActivity, [conversionMapping.seekaActivityMatch], logger)
+    if (matched.length === 0) {
+        logger.verbose('Activity does not match conversion mapping', {conversionMapping, seekaActivity});
+        return;
+    }
+    logger.verbose('Activity matches conversion mapping', {conversionMapping, seekaActivity});
+
+    const enumConversionAction = toEnumConversionAction(conversionMapping.googleConversionAction);
+
+    await fireConversion(enumConversionAction, seekaActivity, googleClickIds, customer, installation, payload, causationId, correlationId, logger);
+}
+
+const fireConversion = async (action: GoogleAdsConversionActionInfoWithEnum, seekaActivity: SeekaActivityAcceptedWebhookContent, clickIds: string[], googleAdsApi: Customer, installation: GoogleAdsAppInstallContext, payload: TrackSeekaGoogleAdsConversionPayload, causationId: string, correlationId: string, logger: Logger) => {
+    const googleGbraidIds = seekaActivity.identifiers?.google?.gbraid || [];
+    const googleWbraidIds = seekaActivity.identifiers?.google?.wbraid || []
+
+    let egressMetric: EgressMetricInfo | null = null;
+
+    switch (action.type) {
+        // case enums.ConversionActionType.WEBPAGE_CODELESS:
+        case enums.ConversionActionType.UPLOAD_CLICKS: {
+            await fireClickConversion(action, seekaActivity, clickIds, googleGbraidIds, googleWbraidIds, googleAdsApi, installation, logger);
+            break;
+        }
+        case enums.ConversionActionType.WEBPAGE:
+        case enums.ConversionActionType.WEBPAGE_CODELESS:
+            // case enums.ConversionActionType.WEBPAGE: 
+        {
+            switch (action.category) {
+                case enums.ConversionActionCategory.SUBMIT_LEAD_FORM:
+                case enums.ConversionActionCategory.CONVERTED_LEAD:
+                case enums.ConversionActionCategory.QUALIFIED_LEAD:
+                case enums.ConversionActionCategory.SIGNUP:
+                case enums.ConversionActionCategory.PAGE_VIEW:
+                    await fireClickConversion(action, seekaActivity, clickIds, googleGbraidIds, googleWbraidIds, googleAdsApi, installation, logger);
+                    break;
+                case enums.ConversionActionCategory.PURCHASE:
+                case enums.ConversionActionCategory.ADD_TO_CART:
+                case enums.ConversionActionCategory.BEGIN_CHECKOUT:
+                    egressMetric = await fireConversionAdjustment(action, seekaActivity, clickIds, googleAdsApi, installation, logger);
+                    break;
+                case enums.ConversionActionCategory.PHONE_CALL_LEAD:
+                    await fireAdCallConversion(action, seekaActivity, clickIds, googleGbraidIds, googleWbraidIds, googleAdsApi, installation, payload, causationId, correlationId, logger);
+                    break;
+                default:
+                    throw new Error(`Conversion category ${enums.ConversionActionCategory[action.category]} not supported for conversion type ${enums.ConversionActionType[action.type]}`);
+            }
+            break;
+        }
+        case enums.ConversionActionType.AD_CALL: {
+            logger.warn("Skipping AD_CALL conversion fire");
+            // await fireAdCallConversion(action, seekaActivity, clickIds, googleGbraidIds, googleWbraidIds, googleAdsApi, installation, payload, causationId, correlationId, logger);
+            break;
+        }
+        default: {
+            throw new Error(`Conversion type ${enums.ConversionActionType[action.type]} not supported`);
+        }
+    }
+
+    if (egressMetric != null) {
+        try {
+            const client = createSeekaTelemetryClient({
+                appId: process.env.SEEKA_APP_ID,
+                appSecret: process.env.SEEKA_APP_SECRET,
+                telemetryEndpointUrl: process.env.SEEKA_TELEMETRY_URL,
+                logger,
+                issuerUrl: process.env.SEEKA_ISSUER_URL
+            }, logger);
+
+            const record = createEgressTelemetryRecord(egressMetric.egressRecord, egressMetric.egressMetrics, seekaActivity);
+
+            await client.sendEgressMetric(record, {
+                appInstallId: installation.applicationInstallId,
+            });
+        } catch (ex) {
+            logger.error("Failed to send egress metric", {
+                err: winston.exceptions.getAllInfo(ex),
+                egressRecord: egressMetric.egressRecord,
+                egressMetrics: egressMetric.egressMetrics
+            });
+        }
+    }
+}
+