def get_metrics(ctx, req *pb.GetMetricsRequest) (*pb.GetMetricsResponse, error) {
     # Parse scaler metadata from the request
     scalerConfig, err := k.parseScalerMetadata(req.ScaledObjectRef, req.MetricName)
     if err != nil {
         return nil, fmt.Errorf("failed to parse scaler metadata: %w", err)
     }
 
     # Get target Kaito Workspace
     var workspace kaito.Workspace
-    err := k.Get(ctx, req.Namespace/Name, &workspace)
+    err = k.Get(ctx, req.Namespace+"/"+req.Name, &workspace)
     if err != nil {
-        return &pb.IsActiveResponse{Result: false}, nil
+        return nil, fmt.Errorf("failed to get workspace: %w", err)
     }
 
     # Get inference pods for this workspace
     pods, err := k.getInferencePods(ctx, workspace)
     if err != nil {
         return nil, fmt.Errorf("failed to get inference pods: %w", err)
     }
 
     # Collect metrics from all pods with intelligent fallback for missing metrics
     var totalValue float64
     var podCount int
     var readyPodCount int
     var missingMetricCount int
 
     for _, pod := range pods {
         podCount++
         if k.isPodReady(pod) {
             readyPodCount++
             value, err := k.getMetricFromPod(ctx, pod, scalerConfig)
             if err != nil {
                 # Pod is ready but metric is unavailable (e.g., endpoint not responding)
                 missingMetricCount++
                 continue
             }
             totalValue += float64(value)
         } else {
             # Pod is not ready (pending, starting, etc.)
             missingMetricCount++
         }
     }
 
     # Apply fallback for missing metrics to prevent flapping
     if missingMetricCount > 0 {
         fallbackValue := k.calculateFallbackValue(scalerConfig, totalValue, readyPodCount-missingMetricCount)
         totalValue += fallbackValue * float64(missingMetricCount)
     }
 
     # Calculate average metric value per pod (including fallback values)
     var avgValue float64
     if podCount > 0 {
         avgValue = totalValue / float64(podCount)
     }
 
     return &pb.GetMetricsResponse{
         MetricValues: []*pb.MetricValue{
             {
                 MetricName:  req.MetricName,
                 MetricValue: int64(avgValue),
             },
         },
     }, nil
 }

 ```bash
-az aks install-cli
+if ! command -v kubectl &> /dev/null; then
+    az aks install-cli
+fi