Function bodies 285 total

func LoadDedicatedAIClusters(ctx context.Context, client dynamic.Interface) (map[string][]models.DedicatedAICluster, error) {
	dacs, err := listDedicatedAIClusters(ctx, client)
	if err != nil {
		return nil, err
	}

	result := make(map[string][]models.DedicatedAICluster)
	for _, dac := range dacs {
		result[dac.TenantID] = append(result[dac.TenantID], dac)
	}
	return result, nil
}

func tenantIDFromLabels(labels map[string]any) string {
	value := labels["tenancy-id"]
	if value != nil {
		if str, ok := value.(string); ok {
			return str
		}
	}
	return "UNKNOWN_TENANCY"
}

func ListGpuNodes(ctx context.Context, clientset kubernetes.Interface, limit int) ([]models.GpuNode, error) {
	nodes, err := clientset.CoreV1().Nodes().List(ctx, v1.ListOptions{
		LabelSelector: "nvidia.com/gpu.present=true",
		Limit:         int64(limit),
	})
	if err != nil {
		return nil, err
	}

	// 1. GPU allocation: as before, using processPodQueries (4 label selectors)
	gpuAllocationMap := make(map[string]int64)
	for _, node := range nodes.Items {
		gpuAllocationMap[node.Name] = 0
	}
	err = processPodQueries(ctx, clientset, gpuPodSelectors, runningPodSelector,
		getGpuAllocations,
		func(node string, usage int64) {
			gpuAllocationMap[node] += usage
		})
	if err != nil {
		return nil, err
	}

	// 2. Pod issues: one extra query for all pods not Running/Succeeded
	badPhaseSelector := "status.phase!=Running,status.phase!=Succeeded"
	badPods, err := clientset.CoreV1().Pods("").List(ctx, v1.ListOptions{
		FieldSelector: badPhaseSelector,
	})
	if err != nil {
		return nil, err
	}
	podI

func getNodeIssues(conditions []corev1.NodeCondition) []string {
	issues := make([]string, 0)
	for _, c := range conditions {
		switch c.Type {
		case corev1.NodeMemoryPressure,
			corev1.NodeDiskPressure,
			corev1.NodePIDPressure,
			corev1.NodeNetworkUnavailable,
			nodeCondGpuBus,
			nodeCondGpuCount:
			if c.Status == corev1.ConditionTrue {
				issues = append(issues, c.Message)
			}
		case corev1.NodeReady:
			// exhaustive check
		}
	}
	return issues
}

func getPodReason(p *corev1.Pod) string {
	if p.Status.Reason != "" {
		return p.Status.Reason
	}
	for _, cs := range p.Status.ContainerStatuses {
		if cs.State.Waiting != nil {
			return cs.State.Waiting.Reason
		}
		if cs.State.Terminated != nil {
			return cs.State.Terminated.Reason
		}
	}
	return "unknown"
}

func isNodeReady(conditions []corev1.NodeCondition) bool {
	for _, condition := range conditions {
		if condition.Type == corev1.NodeReady {
			return condition.Status == corev1.ConditionTrue
		}
	}
	return false
}

func LoadGpuNodes(ctx context.Context, clientset kubernetes.Interface) (map[string][]models.GpuNode, error) {
	nodes, err := ListGpuNodes(ctx, clientset, 0)
	if err != nil {
		return nil, err
	}

	result := make(map[string][]models.GpuNode)
	for _, node := range nodes {
		result[node.NodePool] = append(result[node.NodePool], node)
	}
	return result, nil
}

func (c PodCache) getPodStats(ctx context.Context, namespace string) PodStats {
	pods := c.byNS[namespace]
	idlePods, totalPods := 0, len(pods)
	componentMap := make(map[string]struct{})
	modelNameMap := make(map[string]struct{})

	logger := logging.FromContext(ctx)
	for _, item := range pods {
		labels := getLabels(item)
		if labels[appLabel] == reservationLabel {
			idlePods++
			continue
		}

		annos := getAnnotations(item)
		if modelName, ok := annos[baseModelLabelV2]; ok {
			modelNameMap[modelName] = struct{}{}
		} else if modelName, ok := labels[baseModelLabelV1]; ok {
			modelNameMap[modelName] = struct{}{}
		} else {
			logger.Errorw("workload pod without base model annotation/label",
				"pod", item.GetName(), "namespace", item.GetNamespace())
		}

		if _, ok := labels[servingLabelV1]; ok {
			componentMap[servingLabelV1] = struct{}{}
		} else if _, ok := labels[servingLabelV2]; ok {
			componentMap[servingLabelV2] = struct{}{}
		} else if _, ok := labels[trainingLabelV2]; ok

func getUniqeKey(logger logging.Logger, m map[string]struct{}, namespace string) string {
	if len(m) == 0 {
		return ""
	}

	keys := make([]string, 0, len(m))
	for k := range m {
		keys = append(keys, k)
	}

	if len(keys) > 1 {
		logger.Errorw("multiple configs found on workload pods in namespace",
			"values", keys, "namespace", namespace)
		return ""
	}

	return keys[0]
}

func getLabels(item *unstructured.Unstructured) map[string]string {
	labels := make(map[string]string)
	raw, found, _ := unstructured.NestedMap(item.Object, "metadata", "labels")
	if !found {
		return labels
	}
	for k, v := range raw {
		if s, ok := v.(string); ok {
			labels[k] = s
		}
	}
	return labels
}

func getAnnotations(item *unstructured.Unstructured) map[string]string {
	annos := make(map[string]string)
	raw, found, _ := unstructured.NestedMap(item.Object, "metadata", "annotations")
	if !found {
		return annos
	}
	for k, v := range raw {
		if s, ok := v.(string); ok {
			annos[k] = s
		}
	}
	return annos
}

func buildPodCache(ctx context.Context, client dynamic.Interface) (PodCache, error) {
	cache := PodCache{byNS: make(map[string][]*unstructured.Unstructured)}

	err := processPodQueries(ctx, client, gpuPodSelectors, runningPodSelector,
		listPodsWithSelectors,
		func(ns string, pods []*unstructured.Unstructured) {
			cache.byNS[ns] = append(cache.byNS[ns], pods...)
		})
	if err != nil {
		return cache, err
	}

	return cache, nil
}

func getGpuAllocations(
	ctx context.Context,
	clientset kubernetes.Interface,
	labelSelector string,
	fieldSelector string,
) (map[string]int64, error) {
	pods, err := clientset.CoreV1().Pods("").List(ctx, v1.ListOptions{
		LabelSelector: labelSelector,
		FieldSelector: fieldSelector,
	})
	if err != nil {
		return nil, fmt.Errorf("failed to list pods for selector %q in getGpuAllocations: %w", labelSelector, err)
	}

	usageMap := make(map[string]int64)
	for _, pod := range pods.Items {
		usageMap[pod.Spec.NodeName] += calculatePodGPUs(&pod)
	}

	return usageMap, nil
}

func calculatePodGPUs(pod *corev1.Pod) int64 {
	var total int64
	for _, container := range pod.Spec.Containers {
		if val, ok := container.Resources.Requests[gpuProperty]; ok {
			total += val.Value()
		}
	}
	return total
}

func listPodsWithSelectors(
	ctx context.Context,
	client dynamic.Interface,
	labelSelector string,
	fieldSelector string,
) (map[string][]*unstructured.Unstructured, error) {
	gvr := schema.GroupVersionResource{
		Group:    "",
		Version:  "v1",
		Resource: "pods",
	}
	list, err := client.Resource(gvr).List(ctx, v1.ListOptions{
		LabelSelector: labelSelector,
		FieldSelector: fieldSelector,
	})
	if err != nil {
		return nil, err
	}

	podsMap := make(map[string][]*unstructured.Unstructured)
	for i, pod := range list.Items {
		ns := pod.GetNamespace()
		podsMap[ns] = append(podsMap[ns], &list.Items[i])
	}

	return podsMap, nil
}

func FormatAge(d time.Duration) string {
	switch {
	case d.Hours() >= 48:
		return fmt.Sprintf("%dd", int(d.Hours())/24)
	case d.Hours() >= 1:
		return fmt.Sprintf("%dh", int(d.Hours()))
	case d.Minutes() >= 1:
		return fmt.Sprintf("%dm", int(d.Minutes()))
	default:
		return fmt.Sprintf("%ds", int(d.Seconds()))
	}
}

func ParseAge(s string) int64 {
	if len(s) < 2 {
		return 0
	}
	unit := s[len(s)-1]
	var mult int64
	switch unit {
	case 's':
		mult = 1
	case 'm':
		mult = 60
	case 'h':
		mult = 3600
	case 'd':
		mult = 86400
	default:
		return 0
	}
	v, err := strconv.ParseInt(s[:len(s)-1], 10, 64)
	if err != nil || v < 0 {
		return 0
	}
	return v * mult
}

func NewLoader(ctx context.Context, metadataFile string) loader.Loader {
	l := &Loader{
		metadataFile: metadataFile,
		metadata:     &models.Metadata{},
	}

	if metadataFile != "" {
		m, err := configloader.LoadMetadata(metadataFile)
		if err != nil {
			logging.FromContext(ctx).Errorw("failed to load metadata file", "file", metadataFile, "error", err)
		} else {
			l.metadata = m
		}
	}
	return l
}

func (Loader) LoadBaseModels(ctx context.Context, kubeCfg string, env models.Environment) ([]models.BaseModel, error) {
	client, err := k8s.NewDynamicClientFromKubeConfig(kubeCfg, env.GetKubeContext())
	if err != nil {
		return nil, err
	}
	return k8s.LoadBaseModels(ctx, client)
}

func (Loader) LoadGpuNodes(ctx context.Context, kubeCfg string, env models.Environment) (map[string][]models.GpuNode, error) {
	client, err := k8s.NewClientsetFromKubeConfig(kubeCfg, env.GetKubeContext())
	if err != nil {
		return nil, err
	}
	return k8s.LoadGpuNodes(ctx, client)
}

func (Loader) LoadDedicatedAIClusters(ctx context.Context, kubeCfg string, env models.Environment) (map[string][]models.DedicatedAICluster, error) {
	client, err := k8s.NewDynamicClientFromKubeConfig(kubeCfg, env.GetKubeContext())
	if err != nil {
		return nil, err
	}
	return k8s.LoadDedicatedAIClusters(ctx, client)
}

func GetComputeClient(env models.Environment) (*core.ComputeClient, error) {
	profile := strings.ToUpper(env.Realm)
	provider, err := computeConfigProviderFunc(OciConfigPath, profile, "")
	if err != nil {
		return nil, fmt.Errorf("failed to get OCI config provider: %w", err)
	}
	client, err := computeClientFactory(provider)
	if err != nil {
		return nil, fmt.Errorf("failed to create compute client: %w", err)
	}
	client.SetRegion(env.Region)
	return &client, nil
}

func GetComputeManagementClient(env models.Environment) (*core.ComputeManagementClient, error) {
	profile := strings.ToUpper(env.Realm)
	provider, err := computeConfigProviderFunc(OciConfigPath, profile, "")
	if err != nil {
		return nil, fmt.Errorf("failed to get OCI config provider: %w", err)
	}
	client, err := computeMgmtClientFactory(provider)
	if err != nil {
		return nil, fmt.Errorf("failed to create compute management client: %w", err)
	}
	client.SetRegion(env.Region)
	return &client, nil
}

func getGenAIClientWithDeps(
	env models.Environment,
	providerFn configProviderFunc,
	clientFn genAIClientFunc,
) (*generativeai.GenerativeAiClient, error) {
	profile := strings.ToUpper(env.Realm)
	provider, err := providerFn(OciConfigPath, profile, "")
	if err != nil {
		return nil, fmt.Errorf("failed to get OCI config provider: %w", err)
	}

	client, err := clientFn(provider)
	if err != nil {
		return nil, fmt.Errorf("failed to create GenerativeAI client: %w", err)
	}

	client.SetRegion(env.Region)
	if env.Type != "prod" {
		client.Host = getServiceEndpoint(client.Endpoint(), env.Type)
	}

	return &client, nil
}

func GetGenAIClient(env models.Environment) (*generativeai.GenerativeAiClient, error) {
	return getGenAIClientWithDeps(
		env,
		common.ConfigurationProviderForSessionTokenWithProfile,
		generativeai.NewGenerativeAiClientWithConfigurationProvider,
	)
}

func getServiceEndpoint(serviceEndpoint string, envType string) string {
	prefix := strings.ReplaceAll(envType, "preprod", "ppe")
	u, _ := url.Parse(serviceEndpoint)
	u.Host = fmt.Sprintf("%s.%s", prefix, u.Host)
	return u.String()
}

func getLocalAttributesDI(
	ctx context.Context,
	dirPath string,
	listFilesFunc func(context.Context, string, string) ([]string, error),
	updateLocalAttributesFunc func(string, hclsyntax.Attributes) error,
) (hclsyntax.Attributes, error) {
	tfFiles, err := listFilesFunc(ctx, dirPath, ".tf")
	if err != nil {
		return nil, fmt.Errorf("failed to open file: %w", err)
	}

	attributes := make(hclsyntax.Attributes)
	for _, file := range tfFiles {
		if err := updateLocalAttributesFunc(file, attributes); err != nil {
			return nil, fmt.Errorf("update local attributes: %w", err)
		}
	}

	return attributes, nil
}

func updateLocalAttributes(filepath string, attributes hclsyntax.Attributes) error {
	parser := hclparse.NewParser()
	file, diags := parser.ParseHCLFile(filepath)
	if diags.HasErrors() {
		return fmt.Errorf("terraform diagnostics error: %w", errors.New(diags.Error()))
	}

	// find `locals` block
	for _, block := range file.Body.(*hclsyntax.Body).Blocks {
		switch block.Type {
		case localBlock:
			maps.Copy(attributes, block.Body.Attributes)
		case outputBlock:
			key := block.Labels[0]
			value := block.Body.Attributes[outputValue]
			attributes[key] = value
		}
	}

	return nil
}

func loadLocalValueMap(ctx context.Context, dirPath string, env models.Environment) (map[string]cty.Value, error) { //nolint:cyclop
	logger := logging.FromContext(ctx)
	attributes, err := GetLocalAttributes(ctx, dirPath)
	if err != nil {
		return nil, fmt.Errorf("failed to decode HCL: %w", err)
	}

	executionTarget := cty.ObjectVal(map[string]cty.Value{
		"region": cty.ObjectVal(map[string]cty.Value{
			"realm":              cty.StringVal(env.Realm),
			"public_name":        cty.StringVal(env.Region),
			"public_domain_name": cty.StringVal("example.com"),
		}),
		"tenancy_ocid": cty.StringVal("ocid1.tenancy.oc1..example"),
		"additional_locals": cty.ObjectVal(map[string]cty.Value{
			"environment": cty.StringVal(env.Type),
		}),
	})

	localObject := cty.ObjectVal(map[string]cty.Value{
		"execution_target": executionTarget,
	})

	varObject := cty.ObjectVal(map[string]cty.Value{
		"region":      cty.StringVal(env.Region),
		"environment": cty.StringVal(env.Type),
	})

	dataObject := cty.

func LoadServiceTenancies(ctx context.Context, repoPath string) ([]models.ServiceTenancy, error) {
	dirPath := filepath.Join(repoPath, "shared_modules/shep_targets")
	attributes, err := GetLocalAttributes(ctx, dirPath)
	if err != nil {
		return nil, fmt.Errorf("failed to parse attributes: %w", err)
	}

	tenancyMap := make(map[string]*models.ServiceTenancy)

	for key, attribute := range attributes {
		if key == "tenancy_name_mapping" ||
			strings.HasPrefix(key, "group_") ||
			key == "region_groups" {
			continue
		}

		realm := strings.Split(key, "_")[0]
		value, diags := attribute.Expr.Value(nil)
		if diags.HasErrors() {
			return nil, errors.New(diags.Error())
		}

		tenancy := getServiceTenancy(value, realm)
		fullName := fmt.Sprintf("%s-%s", tenancy.Realm, tenancy.Name)
		if t, ok := tenancyMap[fullName]; ok {
			t.Regions = append(t.Regions, tenancy.Regions...)
		} else {
			tenancyMap[fullName] = tenancy
		}
	}

	tenancies := make([]models.ServiceTenancy, 0, len(tenancyMap))
	fo

func getServiceTenancy(object cty.Value, realm string) *models.ServiceTenancy {
	result := models.ServiceTenancy{
		Realm: realm,
	}

	for name, value := range object.AsValueMap() {
		switch name {
		case "tenancy_name":
			result.Name = value.AsString()
		case "home_region":
			result.HomeRegion = value.AsString()
		case "regions":
			var regions []string
			for _, region := range value.AsValueSlice() {
				regions = append(regions, region.AsString())
			}
			result.Regions = regions
		case "environment":
			result.Environment = value.AsString()
		}
	}

	return &result
}

func LoadGpuPools(ctx context.Context, repoPath string, env models.Environment) ([]models.GpuPool, error) {
	var gpuPools []models.GpuPool

	// self-managed pools
	dirPath := filepath.Join(repoPath, "shared_modules/instance_pools_config")
	pools, err := loadGpuPools(ctx, dirPath, "env_instance_pools_config", false, env)
	if err != nil {
		return nil, fmt.Errorf("failed to parse HCL file: %w", err)
	}

	gpuPools = append(gpuPools, pools...)

	// self-managed pools (cluster network)
	dirPath = filepath.Join(repoPath, "shared_modules/cluster_networks_config")
	pools, err = loadGpuPools(ctx, dirPath, "env_cluster_networks_config", false, env)
	if err != nil {
		return nil, fmt.Errorf("failed to parse HCL file: %w", err)
	}

	gpuPools = append(gpuPools, pools...)

	// oke-managed pools
	dirPath = filepath.Join(repoPath, "shared_modules/oci_oke_nodepools_config")
	pools, err = loadGpuPools(ctx, dirPath, "env_nodepools_config", true, env)
	if err != nil {
		return nil, fmt.Errorf("failed to p

func loadGpuPools(ctx context.Context, dirPath, poolConfigName string, isOkeManaged bool,
	env models.Environment,
) ([]models.GpuPool, error) {
	valueMap, err := loadLocalValueMap(ctx, dirPath, env)
	if err != nil {
		return nil, err
	}

	poolsValue, ok := valueMap[poolConfigName]
	if !ok {
		return nil, fmt.Errorf("node pools config %s not resolved", poolConfigName)
	}

	var gpuPools []models.GpuPool
	for name, value := range poolsValue.AsValueMap() {
		pool := models.GpuPool{Name: name, IsOkeManaged: isOkeManaged, CapacityType: "on-demand", Status: "..."}
		for k, v := range value.AsValueMap() {
			switch k {
			case "shape":
				pool.Shape = v.AsString()
			case "size", "node_pool_size":
				size, _ := v.AsBigFloat().Int64()
				pool.Size = int(size)
			case "capacity_type":
				pool.CapacityType = v.AsString()
			case "placement_logical_ad":
				pool.AvailabilityDomain = extractAvailabilityDomain(v)
			}
		}

		if strings.Contains(pool.Shape, "GPU") {
			gpuPools = append(gpuPools

func extractAvailabilityDomain(v cty.Value) string {
	t := v.Type()
	if t.IsPrimitiveType() && t.FriendlyName() == "string" {
		return v.AsString()
	} else if t.IsListType() || t.IsTupleType() {
		if slice := v.AsValueSlice(); len(slice) > 0 {
			s := slice[0].AsString()
			if parts := strings.Split(s, "-AD-"); len(parts) == 2 {
				return "AD-" + parts[1]
			}
		}
	}
	return ""
}

func LoadModelArtifacts(ctx context.Context, repoPath string, env models.Environment) (map[string][]models.ModelArtifact, error) {
	dirPath := filepath.Join(repoPath, "shared_modules/tensorrt_models_config")
	valueMap, err := loadLocalValueMap(ctx, dirPath, env)
	if err != nil {
		return nil, err
	}

	modelMapValue, ok := valueMap["all_models_map"]
	if !ok {
		return nil, fmt.Errorf("all_models_map: %w", ErrModelArtifactMapNotResolved)
	}

	modelArtifactMap := map[string][]models.ModelArtifact{}
	for modelName, value := range modelMapValue.AsValueMap() {
		modelArtifacts := make([]models.ModelArtifact, 0, 4)
		for trtVersion, v1 := range value.AsValueMap() {
			for gpuShape, v2 := range v1.AsValueMap() {
				for gpuCount, v3 := range v2.AsValueMap() {
					artifact := models.ModelArtifact{
						Name:            v3.AsString(),
						TensorRTVersion: trtVersion,
						GpuCount:        extractGpuNumber(gpuCount),
						GpuShape:        gpuShape,
						ModelName:       modelName,
					}

func createAvailabilityDomains() cty.Value {
	// data.oci_identity_availability_domains.ad_list.availability_domains
	ad1 := cty.ObjectVal(map[string]cty.Value{"name": cty.StringVal("AD-1")})
	ads := cty.ListVal([]cty.Value{ad1})
	adsValue := cty.ObjectVal(map[string]cty.Value{"availability_domains": ads})
	return cty.ObjectVal(map[string]cty.Value{"ad_list": adsValue})
}

func CopyItemName(item any, env models.Environment, logger logging.Logger) {
	if item == nil {
		logger.Errorw("no item selected for copying name")
		return
	}

	if dac, ok := item.(*models.DedicatedAICluster); ok {
		id := dac.GetID(env.Realm, env.Region)
		if err := clipboardWriteAll(id); err != nil {
			logger.Errorw("failed to copy id to clipboard", "error", err)
		}
	} else if to, ok := item.(models.NamedItem); ok {
		if err := clipboardWriteAll(to.GetName()); err != nil {
			logger.Errorw("failed to copy name to clipboard", "error", err)
		}
	} else {
		logger.Errorw("unsupported item type for copying name", "item", item)
	}
}

func CopyTenantID(item any, env models.Environment, logger logging.Logger) {
	if item == nil {
		logger.Errorw("no item selected for copying tenant ID")
		return
	}

	if dac, ok := item.(*models.DedicatedAICluster); ok {
		tenantID := dac.GetTenantID(env.Realm)
		if err := clipboardWriteAll(tenantID); err != nil {
			logger.Errorw("failed to copy tenantID to clipboard", "error", err)
		}
	} else if to, ok := item.(models.TenancyOverride); ok {
		if err := clipboardWriteAll(to.GetTenantID()); err != nil {
			logger.Errorw("failed to copy tenantID to clipboard", "error", err)
		}
	} else {
		logger.Errorw("unsupported item type for copying tenant ID", "item", item)
	}
}

func DeleteDedicatedAICluster(ctx context.Context, dac *models.DedicatedAICluster, env models.Environment, logger logging.Logger) error {
	ctx, cancel := context.WithTimeout(ctx, 10*time.Minute)
	defer cancel()

	client, err := getGenAIClient(env)
	if err != nil {
		return fmt.Errorf("failed to create GenerativeAI client: %w", err)
	}

	dacID := dac.GetID(env.Realm, env.Region)
	getReq := generativeai.GetDedicatedAiClusterRequest{
		DedicatedAiClusterId: &dacID,
	}
	getResp, err := client.GetDedicatedAiCluster(ctx, getReq)
	if err != nil {
		return fmt.Errorf("failed to get DedicatedAiCluster: %w", err)
	}

	logger.Infow("deleting DedicatedAiCluster", "id", getResp.Id, "name", getResp.DisplayName)
	if err := deleteEndpointsInDAC(ctx, client, &getResp.DedicatedAiCluster, logger); err != nil {
		return err
	}

	delReq := generativeai.DeleteDedicatedAiClusterRequest{
		DedicatedAiClusterId: &dacID,
	}
	delResp, err := client.DeleteDedicatedAiCluster(ctx, delReq)
	if err != nil {
		return 

func deleteEndpointsInDAC(
	ctx context.Context,
	client genAI,
	dac *generativeai.DedicatedAiCluster,
	logger logging.Logger,
) error {
	compartmentID := dac.CompartmentId
	listReq := generativeai.ListEndpointsRequest{
		CompartmentId: compartmentID,
	}
	listResp, err := client.ListEndpoints(ctx, listReq)
	if err != nil {
		return fmt.Errorf("failed to list endpoints: %w", err)
	}

	logger.Infow("endpoints found", "count", len(listResp.Items))

	var count int32
	const maxConcurrent = 5
	sem := make(chan struct{}, maxConcurrent)
	g, gctx := errgroup.WithContext(ctx)

	for _, item := range listResp.Items {
		if *item.DedicatedAiClusterId != *dac.Id {
			continue
		}

		sem <- struct{}{}
		count++
		ep := item // capture loop variable
		g.Go(func() error {
			defer func() { <-sem }()
			return deleteEndpoint(gctx, client, &ep, logger)
		})
	}

	if err := g.Wait(); err != nil {
		return err
	}

	logger.Infow("endpoints deleted", "count", count)
	return nil
}

func deleteEndpoint(
	ctx context.Context,
	client genAI,
	endpoint *generativeai.EndpointSummary,
	logger logging.Logger,
) error {
	logger.Infow("deleting endpoint", "id", endpoint.Id, "name", endpoint.DisplayName)
	delReq := generativeai.DeleteEndpointRequest{
		EndpointId: endpoint.Id,
	}
	delResp, err := client.DeleteEndpoint(ctx, delReq)
	if err != nil {
		return fmt.Errorf("failed to delete endpoint: %w", err)
	}

	// Poll work request status before returning
	if err := waitForWorkRequest(ctx, client, delResp.OpcWorkRequestId, logger); err != nil {
		return fmt.Errorf("endpoint deletion did not complete successfully: %w", err)
	}

	logger.Infow("endpoint is deleted successfully", "id",
		endpoint.Id, "opc-request-id", delResp.OpcRequestId)

	return nil
}

func waitForWorkRequest(
	ctx context.Context,
	client genAI,
	workRequestID *string,
	logger logging.Logger,
) error {
	const interval = 5 * time.Second
	ticker := time.NewTicker(interval)
	defer ticker.Stop()

	for {
		select {
		case <-ctx.Done():
			return ctx.Err()
		case <-ticker.C:
			wrReq := generativeai.GetWorkRequestRequest{WorkRequestId: workRequestID}
			wrResp, err := client.GetWorkRequest(ctx, wrReq)
			if err != nil {
				logger.Infow("failed to get work request status", "level", "warn", "workRequestId", *workRequestID, "err", err)
				continue
			}
			status := string(wrResp.Status)
			if status == "SUCCEEDED" {
				return nil
			}
			if status == "FAILED" {
				return fmt.Errorf("work request %s failed", *workRequestID)
			}
			// Otherwise, keep polling for Accepted/InProgress
		}
	}
}

func SoftResetInstance(
	ctx context.Context,
	node *models.GpuNode,
	env models.Environment,
	logger logging.Logger,
) error {
	client, err := newComputeClient(env)
	if err != nil {
		return fmt.Errorf("failed to create compute client: %w", err)
	}

	logger.Infow("rebooting node", "id", node.ID, "name", node.Name)
	resp, err := client.InstanceAction(ctx, core.InstanceActionRequest{
		InstanceId: common.String(node.ID),
		Action:     core.InstanceActionActionSoftreset,
	})
	if err != nil {
		reqID := ""
		if resp.OpcRequestId != nil {
			reqID = *resp.OpcRequestId
		}
		return fmt.Errorf("failed to soft reset instance: %w, request id: %s", err, reqID)
	}

	logger.Infow("reboot request is submitted successfully", "id",
		node.ID, "opc-request-id", resp.OpcRequestId)
	return nil
}

func IncreasePoolSize(
	ctx context.Context,
	pool *models.GpuPool,
	env models.Environment,
	logger logging.Logger,
) error {
	mgmtClient, err := newComputeMgmtClient(env)
	if err != nil {
		return fmt.Errorf("failed to create compute management client: %w", err)
	}

	if pool.ActualSize >= pool.Size {
		return nil
	}
	newSize := pool.Size
	logger.Infow("scaling up instance pool", "id", pool.ID, "name", pool.Name, "newSize", newSize)
	resp, err := mgmtClient.UpdateInstancePool(ctx, core.UpdateInstancePoolRequest{
		InstancePoolId: common.String(pool.ID),
		UpdateInstancePoolDetails: core.UpdateInstancePoolDetails{
			Size: common.Int(newSize),
		},
	})
	if err != nil {
		reqID := ""
		if resp.OpcRequestId != nil {
			reqID = *resp.OpcRequestId
		}
		return fmt.Errorf("failed to update instance pool: %w, request id: %s", err, reqID)
	}
	logger.Infow("scaling request is submitted successfully", "id",
		pool.ID, "opc-request-id", resp.OpcRequestId)
	return nil
}

func TerminateInstance(
	ctx context.Context,
	node *models.GpuNode,
	env models.Environment,
	logger logging.Logger,
) error {
	client, err := newComputeClient(env)
	if err != nil {
		return fmt.Errorf("failed to create compute client: %w", err)
	}

	logger.Infow("deleting node", "id", node.ID, "name", node.Name)
	resp, err := client.TerminateInstance(ctx, core.TerminateInstanceRequest{
		InstanceId:         common.String(node.ID),
		PreserveBootVolume: common.Bool(false),
	})
	if err != nil {
		reqID := ""
		if resp.OpcRequestId != nil {
			reqID = *resp.OpcRequestId
		}
		return fmt.Errorf("failed to terminate instance: %w, request id: %s", err, reqID)
	}
	logger.Infow("deletion request is submitted successfully", "id",
		node.ID, "opc-request-id", resp.OpcRequestId)
	return nil
}

func PopulateGpuPools(
	ctx context.Context,
	gpuPools []models.GpuPool,
	env models.Environment,
	compartmentID string,
) error {
	if len(gpuPools) == 0 || compartmentID == "" {
		return nil // nothing to do
	}

	mgmtClient, err := newComputeMgmtClient(env)
	if err != nil {
		return err
	}

	req := core.ListInstancePoolsRequest{
		CompartmentId: &compartmentID,
	}
	resp, err := mgmtClient.ListInstancePools(ctx, req)
	if err != nil {
		reqID := ""
		if resp.OpcRequestId != nil {
			reqID = *resp.OpcRequestId
		}
		return fmt.Errorf("failed to list instance pools: %w, request id: %s", err, reqID)
	}

	gpuPoolMap := make(map[string]*models.GpuPool)
	for i := range gpuPools {
		gpuPoolMap[gpuPools[i].Name] = &gpuPools[i]
		gpuPools[i].Status = "NONEXIST"
	}

	for _, summary := range resp.Items {
		if pool, ok := gpuPoolMap[*summary.DisplayName]; ok {
			pool.ID = *summary.Id
			pool.ActualSize = *summary.Size
			pool.Status = string(summary.LifecycleState)
		}
	}
	return nil
}

func (e EditTarget) String() string {
	switch e {
	case NoneTarget:
		return "none"
	case FilterTarget:
		return "filter"
	case AliasTarget:
		return "alias"
	default:
		return "unknown"
	}
}

func (m InputMode) String() string {
	switch m {
	case UnknownInput:
		return "unknown"
	case EditInput:
		return "edit"
	case NormalInput:
		return "normal"
	default:
		return "unknown"
	}
}

func (v ViewMode) String() string {
	switch v {
	case ListView:
		return "List"
	case DetailsView:
		return "Details"
	case LoadingView:
		return "Loading"
	case HelpView:
		return "Help"
	case ErrorView:
		return "Error"
	case ExportView:
		return "Export"
	default:
		return "Unknown"
	}
}

func (m *Model) copyItemNameCmd(item any) tea.Cmd {
	return func() tea.Msg {
		actions.CopyItemName(item, m.environment, m.logger)
		return nil
	}
}