LCOV - code coverage report
Current view: top level - src/workbench/extensions/agent/experiments - freeUsePlacement.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 30.4 % 46 14
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { readonly, ref, watch } from 'vue'
       2              : 
       3              : import {
       4              :   isAuthenticatedConfigLoaded,
       5              :   remoteConfig
       6              : } from '@/platform/remoteConfig/remoteConfig'
       7              : import { useTelemetry } from '@comfyorg/telemetry'
       8              : import type {
       9              :   AgentFreeUseNoticeMetadata,
      10              :   AgentFreeUseVariant
      11              : } from '@comfyorg/telemetry/types'
      12              : import { AGENT_FREE_USE_PLACEMENTS } from '@comfyorg/telemetry/types'
      13              : import { getDevOverride } from '@/utils/devFeatureFlagOverride'
      14              : import { getSessionOverride } from '@/utils/sessionFeatureFlagOverride'
      15              : 
      16              : import { useAgentPanelStore } from '@/workbench/extensions/agent/stores/agent/agentPanelStore'
      17              : 
      18            1 : export const FREE_USE_PLACEMENT_FLAG = 'agent-free-use-message-placement'
      19              : 
      20            1 : export const FREE_USE_VARIANTS = [
      21              :   'control',
      22              :   ...AGENT_FREE_USE_PLACEMENTS
      23              : ] as const satisfies readonly AgentFreeUseVariant[]
      24              : 
      25              : export type FreeUseVariant = AgentFreeUseVariant
      26              : 
      27            1 : export const LOCAL_FREE_USE_PLACEMENT = 'near-composer' satisfies FreeUseVariant
      28              : 
      29            0 : function isFreeUseVariant(value: unknown): value is FreeUseVariant {
      30            0 :   return FREE_USE_VARIANTS.some((variant) => variant === value)
      31              : }
      32              : 
      33            1 : export function useFreeUsePlacement(isCloudDistribution: boolean) {
      34            1 :   const panelStore = useAgentPanelStore()
      35            1 :   const assigned = ref<FreeUseVariant>('control')
      36              : 
      37            1 :   const sessionOverride = getSessionOverride<unknown>(FREE_USE_PLACEMENT_FLAG)
      38            1 :   const override =
      39              :     sessionOverride !== undefined
      40              :       ? sessionOverride
      41              :       : getDevOverride<unknown>(FREE_USE_PLACEMENT_FLAG)
      42            1 :   const hasQaOverride = override !== undefined
      43              : 
      44            0 :   function assign(): void {
      45            0 :     const served = remoteConfig.value[FREE_USE_PLACEMENT_FLAG]
      46            0 :     if (!isFreeUseVariant(served)) {
      47            0 :       assigned.value = 'control'
      48            0 :       return
      49              :     }
      50            0 :     assigned.value = served
      51            0 :     if (panelStore.reportedFreeUseExposure) return
      52            0 :     const telemetry = useTelemetry()
      53            0 :     if (!telemetry) return
      54            0 :     panelStore.reportedFreeUseExposure = true
      55            0 :     telemetry.trackAgentFreeUseExposure({
      56              :       placement: served,
      57              :       [`$feature/${FREE_USE_PLACEMENT_FLAG}`]: served
      58              :     })
      59              :   }
      60              : 
      61            1 :   if (hasQaOverride) {
      62            0 :     if (isFreeUseVariant(override)) assigned.value = override
      63            1 :   } else if (!isCloudDistribution) {
      64            1 :     assigned.value = LOCAL_FREE_USE_PLACEMENT
      65            0 :   } else if (isAuthenticatedConfigLoaded.value) {
      66            0 :     assign()
      67              :   } else {
      68            0 :     const stop = watch(isAuthenticatedConfigLoaded, (authenticated) => {
      69            0 :       if (!authenticated) return
      70            0 :       assign()
      71            0 :       stop()
      72              :     })
      73              :   }
      74              : 
      75            1 :   if (!hasQaOverride && isCloudDistribution) {
      76            0 :     watch(
      77              :       () => remoteConfig.value[FREE_USE_PLACEMENT_FLAG],
      78              :       () => {
      79            0 :         if (isAuthenticatedConfigLoaded.value) assign()
      80              :       }
      81              :     )
      82            0 :     watch(
      83              :       () => panelStore.isOpen,
      84              :       (isOpen) => {
      85            0 :         if (isOpen && isAuthenticatedConfigLoaded.value) assign()
      86              :       }
      87              :     )
      88              :   }
      89              : 
      90            0 :   function reportNotice(metadata: AgentFreeUseNoticeMetadata): void {
      91            0 :     if (hasQaOverride) return
      92            0 :     if (metadata.action === 'shown' && panelStore.reportedFreeUseImpression)
      93            0 :       return
      94            0 :     const telemetry = useTelemetry()
      95            0 :     if (!telemetry) return
      96            0 :     if (metadata.action === 'shown') panelStore.reportedFreeUseImpression = true
      97            0 :     telemetry.trackAgentFreeUseNotice(
      98              :       isCloudDistribution ? metadata : { ...metadata, deployment: 'local' }
      99              :     )
     100              :   }
     101              : 
     102            1 :   return {
     103              :     variant: readonly(assigned),
     104              :     reportNotice
     105              :   }
     106              : }
        

Generated by: LCOV version 2.0-1